tools 0.4.4 → 0.4.5

data/test/mini_log.rb

@@ -0,0 +1,21 @@
+class ToolsModuleTest < Minitest::Test
+
+  def self.test_order
+    :sorted
+  end
+
+  def test_log_A
+    ToolsFiles.remove_file (File.dirname __dir__) + '/teste.log'
+    ToolsLog.create_log_file 'test', (File.dirname __dir__) + '/teste.log'
+    ToolsLog.create_log_file 'test', (File.dirname __dir__) + '/teste.log'
+    FileUtils.touch (File.dirname __dir__) + '/teste.log', :mtime => (Time.now - 86400)
+    ToolsLog.test_info  'Minitest.: test_log'
+    ToolsLog.test_warn  'Minitest.: test_log'
+    ToolsLog.test_error 'Minitest.: test_log'
+    ToolsLog.test_debug 'Minitest.: test_log'
+    ToolsLog.test_ucolor 'Minitest.: test_log'
+    ToolsLog.test_ucolorx 'Minitest.: test_log'
+    ToolsFiles.remove_file (File.dirname __dir__) + '/teste.log'
+  end
+
+end

data/test/mini_net.rb

@@ -0,0 +1,223 @@
+class ToolsModuleTest < Minitest::Test
+
+  def self.test_order
+    :sorted
+  end
+
+  def test_net_A_ping?
+    assert_equal (ToolsNet.ping? '127.0.0.1'), true
+  end
+
+  def test_net_B_work_with_ips
+    ip = ToolsNet.get_current_ip
+    assert_equal (ToolsNet.valid_ip? ip), true
+    assert_equal (ToolsNet.validate_ipaddress ip)[:status], true
+    assert_equal (ToolsNet.validate_ipaddress ip)[:type], 'ip'
+    assert_equal (ToolsNet.validate_ipaddress '100.0.0.0/28')[:status], true
+    assert_equal (ToolsNet.validate_ipaddress '100.0.0.0/28')[:type], 'mask'
+    assert_equal (ToolsNet.validate_ipaddress ip+'x')[:status], false
+    assert_equal (ToolsNet.validate_ipaddress '100.0.0.0/28x')[:status], false
+    assert_equal (ToolsNet.is_backend? '10.1.2.3'), true
+    assert_equal (ToolsNet.is_backend? '201.0.0.1'), false
+    assert_equal (ToolsNet.valid_network? ip), false
+    assert_equal (ToolsNet.valid_network? '110.0.0.0/28'), true
+    assert_equal (ToolsNet.resolv_dns 'www.wikipedia.org'), "208.80.154.224"
+    assert_nil   (ToolsNet.resolv_dns 'www.wikipedia.orgx')
+    assert_equal (ToolsNet.resolv_ip_name "208.80.154.224"), "text-lb.eqiad.wikimedia.org"
+    assert_equal (ToolsNet.resolv_ip_name "208.80.154.224x"), "cannot interpret as address: 208.80.154.224x"
+  end
+
+  def test_net_C_valid_port
+    assert_equal (ToolsNet.valid_port? 8888), true
+    assert_equal (ToolsNet.valid_port? -1), false
+    assert_equal (ToolsNet.valid_port? 0), false
+    assert_equal (ToolsNet.valid_port? 100000), false
+  end
+
+
+  def test_net_D_doreq
+    resource = RestClient::Resource.new('www.google.com')
+    validate_opts = {quit_on_error: false}
+    method_opts   = {}
+    params={:method => :get}
+    uri = ''
+    if params.has_key? :expected
+      validate_opts[:expected] = params[:expected]
+    end
+    if params.has_key? :data
+      method_opts = {:data => params[:data].to_json}
+    end
+    result =  ToolsNet.doreq resource,
+                                uri,
+                                params[:method],
+                                show_progress: true,
+                                method_opts: method_opts,
+                                validate_opts: validate_opts,
+                                retry_opts: {
+                                  attempts: 1,
+                                  when_res: [nil, [], {}, ''],
+                                  when_code: []}
+    assert_equal result.code, 200
+  end
+
+
+end
+
+
+
+
+  # # Resolv a ip to a dns.
+  # #
+  # # @param           ip variable ip to resolv
+  # # @return [String] Dns name resolved
+  # def self.resolv_ip_name ip
+  #   s = ''
+  #   begin
+  #     ret = Resolv.new.getname(ip)
+  #     return ret.instance_variable_get('@labels').join('.')
+  #   rescue Exception => e
+  #     case e.message
+  #       when "Dnsruby::NXDomain"
+  #         return nil
+  #       else
+  #         return e.message
+  #     end
+  #   end
+  #   return s.strip
+  # end
+
+
+  # # Resolv a dns to a ip.
+  # #
+  # # @param domain variable ip to resolv
+  # # @return [String] Dns address resolved
+  # def self.resolv_dns domain
+  #   begin
+  #     dns = Dnsruby::DNS.new()
+  #     ret = dns.getaddress(domain).to_s
+  #   rescue Exception => e
+  #     case e.message
+  #       when "Dnsruby::NXDomain"
+  #         return nil
+  #       else
+  #         return e.message
+  #     end
+  #   end
+  #   return ret
+  # end
+
+
+  # # Do the request, validate and decode response and do the retries if needed
+  # #
+  # # - restclient_obj: initialized RestClient object
+  # # - path: URL path to request
+  # # - method: symbol for HTTP Method to request
+  # # - method_opts: options as passed to a RestClient call
+  # # - validate_opts: options for response validation as used with
+  # # validate_decode_response()
+  # # - retry_opts: when_res: [nil, [], {}, 'str'], when_code: [404, 500],
+  # # conditionals to retry even if no exceptions were catched
+  # # @param restclient_obj Rest Object
+  # # @param path           path
+  # # @param method         method
+  # # @param method_opts    method opts
+  # # @param validate_opts  validate opts
+  # # @param retry_opts     retry opts
+  # # @param show_progress  default false
+  # def self.doreq( restclient_obj, path, method, method_opts: {},validate_opts: {}, retry_opts: {}, show_progress: false)
+  #   res = nil
+  #   code = nil
+  #   data = method_opts.fetch(:data, nil)
+  #   method_opts.delete(:data)
+
+  #   # Retry loop due to:
+  #   # - 404 from Router API right after applying patch over a target
+  #   # - Intermittent connection reset from Manager API (HTTPS)
+  #   retries = retry_opts.fetch(:attempts, 10)
+  #   1.upto(retries) do |try|
+  #     flag_error = false
+  #     # The request
+  #     begin
+  #       restclient_obj[path].send(method, *data, **method_opts) do |response, request, result|
+  #         res  = validate_decode_response(response, request, result, validate_opts)
+  #         code = result.code.to_i
+  #       end
+  #     rescue Exception => error
+  #       flag_error = true
+  #     end
+  #     # Other conditionals to retry
+  #     unless retry_opts.empty?
+  #       if retry_opts.has_key?(:when_res)
+  #         flag_error = true if retry_opts[:when_res].include?(res)
+  #       end
+  #       if retry_opts.has_key?(:when_code)
+  #         flag_error = true if retry_opts[:when_code].include?(code)
+  #       end
+  #     end
+  #     return res unless flag_error # got response, break the loop
+  #     doReqMSG = sprintf "%d/%d", try, retries
+  #     if show_progress
+  #        ap doReqMSG
+  #     end
+  #     if try >= retries
+  #       ap doreq_code
+  #       return nil
+  #     else
+  #       sleep 1 # wait before next
+  #     end
+  #   end
+  # end
+
+  # # Return a valid decode response.
+  # #
+  # # @param   response
+  # # @param   request
+  # # @param   result
+  # # @param   validate_opts
+  # # @return [Object type] Array or Proc or String or Error
+  # def self.validate_decode_response response, request, result, validate_opts
+  #   if validate_opts.has_key? :expected
+  #     expected = validate_opts[:expected]
+  #     case expected.class.name
+  #     when 'Array'
+  #       if validate_opts[:expected].include? response
+  #         return true
+  #       else
+  #         return false
+  #       end
+  #     when 'Proc'
+  #       response = expected.call(response, request, result)
+  #       return response
+  #     when 'String'
+  #       return result   if validate_opts[:expected].eql? 'result'
+  #       return request  if validate_opts[:expected].eql? 'request'
+  #       return response if validate_opts[:expected].eql? 'response'
+  #     else
+  #       ap expected.class.name
+  #       return response
+  #     end
+  #   else
+  #     return response
+  #   end
+  #   return true
+  # end
+
+
+  # # Validate.: port number between valid range?.
+  # #
+  # # @param            port number to be validate.
+  # # @return [Boolean]
+  # def self.valid_port? port
+  #   if port.to_s.strip.match(/^\d{1,5}(?!\d)$/).nil?
+  #     return false
+  #   end
+  #   unless port.to_i.between?(1, 65535)
+  #     return false
+  #   end
+  #   return true
+  # end
+
+
+
+
+

data/test/mini_object.rb

@@ -0,0 +1,35 @@
+class ToolsModuleTest < Minitest::Test
+
+  def self.test_order
+    :sorted
+  end
+
+  def test_object_A_boolean?
+   test = true
+   assert_equal test.boolean?, true
+  end
+
+  def test_object_B_true?
+   test = true
+   assert_equal test.true?, true
+  end
+
+    def test_object_C_false?
+   test = false
+   assert_equal test.false?, true
+  end
+
+    def test_object_D_symbol?
+   test = :true
+   assert_equal test.symbol?, true
+  end
+
+    def test_object_E_string?
+   test = 'string'
+   assert_equal test.string?, true
+  end
+
+end
+
+
+

data/test/mini_prompt.rb

@@ -0,0 +1,82 @@
+class ToolsModuleTest < Minitest::Test
+
+  def self.test_order
+    :sorted
+  end
+
+  def test_prompt_A_yes?
+    mock = MiniTest::Mock.new
+    def mock.yes? *args; true; end
+    TTY::Prompt.stub :new, mock do
+      assert_equal (ToolsPrompt.yes? 'Continue'), true
+    end
+  end
+
+  def test_prompt_B_no?
+    mock = MiniTest::Mock.new
+    def mock.no? *args; true; end
+    TTY::Prompt.stub :new, mock do
+      assert_equal (ToolsPrompt.no? 'Continue'), true
+    end
+  end
+
+  def test_prompt_C_ask
+    mock = MiniTest::Mock.new
+    def mock.ask *args; 'teste'; end
+    TTY::Prompt.stub :new, mock do
+      assert_equal (ToolsPrompt.ask 'Name'), 'teste'
+    end
+  end
+
+  def test_prompt_D_mask
+    mock = MiniTest::Mock.new
+    def mock.mask *args; 'teste'; end
+    TTY::Prompt.stub :new, mock do
+      assert_equal (ToolsPrompt.mask 'Name'), 'teste'
+    end
+  end
+
+  def test_prompt_E_expand
+    mock = MiniTest::Mock.new
+    def mock.expand *args; :yes; end
+    TTY::Prompt.stub :new, mock do
+      choices = [{
+        key: 'Y',
+        name: 'Overwrite',
+        value: :yes
+      }, {
+        key: 'n',
+        name: 'Skip',
+        value: :no
+      }]
+      assert_equal (ToolsPrompt.expand 'Overwirte Gemfile?', choices), :yes
+    end
+  end
+
+  def test_prompt_F_select
+    mock = MiniTest::Mock.new
+    def mock.select *args; 'vodka'; end
+    TTY::Prompt.stub :new, mock do
+      assert_equal (ToolsPrompt.select "Select drinks?", 'vodka', 'beer'), 'vodka'
+    end
+  end
+
+
+  def test_prompt_G_multi_select
+    mock = MiniTest::Mock.new
+    def mock.multi_select *args; 'vodka'; end
+    TTY::Prompt.stub :new, mock do
+      assert_equal (ToolsPrompt.multi_select "Select drinks?", 'vodka', 'beer'), 'vodka'
+    end
+  end
+
+  def test_prompt_G_enum_select
+    mock = MiniTest::Mock.new
+    def mock.enum_select *args; 'vodka'; end
+    TTY::Prompt.stub :new, mock do
+      assert_equal (ToolsPrompt.enum_select "Select drinks?", 'vodka', 'beer'), 'vodka'
+    end
+  end
+
+
+end

data/test/mini_string.rb

@@ -0,0 +1,48 @@
+class ToolsModuleTest < Minitest::Test
+
+  def self.test_order
+    :sorted
+  end
+
+  def test_string_A_fix
+   assert_equal "TESTE".fix(10,'xy'), 'xyxyxTESTE'
+   assert_equal "TESTE".fix(-10,'xy'), 'TESTExyxyx'
+  end
+
+  def test_string_B_encrypt_decrypt
+    msg       = "teste do encrypt"
+    passwd    = 'tools999'
+    encrypted = msg.encrypt passwd
+    assert_equal msg, (encrypted.decrypt passwd)
+  end
+
+  def test_string_C_numeric?
+    assert_equal true, "100".numeric?
+    assert_equal false, "xx".numeric?
+  end
+
+  def test_string_D_num?
+    assert_equal true, "100".num?
+    assert_equal false, "xx".num?
+  end
+
+  def test_string_E_alnum?
+    assert_equal true, "1x0".alnum?
+    assert_equal true, "1xx".alnum?
+  end
+
+  def test_string_F_alpha?
+    assert_equal false, "100".alpha?
+    assert_equal true, "xx".alpha?
+  end
+
+  def test_string_G_help?
+    assert_equal true, '?'.help?
+    assert_equal true, '-h'.help?
+    assert_equal true, '--help'.help?
+    assert_equal true, 'help'.help?
+    assert_equal false, 'eelp'.help?
+  end
+
+end
+

data/test/mini_utils.rb

@@ -0,0 +1,96 @@
+class ToolsModuleTest < Minitest::Test
+
+  def self.test_order
+    :sorted
+  end
+
+  def test_utils_A_symbolize_keys
+    hash = {'key' => 1, :key1 => 'A', :key3 => {:k1 => 1}}
+    hash = ToolsUtil.symbolize_keys(hash)
+    assert_equal hash, {:key => 1, :key1 => 'A', :key3 => {:k1 => 1}}
+  end
+
+  def test_utils_C_valid_json_true?
+    data = {:k1 => "v1", :k2 => "v2"}.to_json
+    assert_equal true, (ToolsUtil.valid_json? data)
+  end
+
+  def test_utils_D_valid_json_error?
+    data = {:k1 => "v1", :k2 => "v2"}.to_json + "error"
+    assert_equal false, (ToolsUtil.valid_json? data)
+  end
+
+  def test_utils_E_valid_yaml_true?
+    data = {:k1 => "v1", :k2 => "v2"}.to_yaml
+    assert_equal true, (ToolsUtil.valid_yaml? data)
+  end
+
+  def test_utils_F_valid_yaml_error?
+    data = {:k1 => "v1", :k2 => "v2"}.to_yaml + "error"
+    assert_equal false, (ToolsUtil.valid_yaml? data)
+  end
+
+  def test_utils_G_get_date
+    now = DateTime.now
+    (ToolsUtil.get_date '%Y %m %d %H %M').split(' ').each do |d|
+      assert_equal (now.to_s.include? d), true
+    end
+  end
+
+  def test_utils_H_set_get_variable
+    ToolsUtil.set_variable 'teste', 'A'
+    assert_equal (ToolsUtil.get_variable 'teste'), 'A'
+  end
+
+  def test_utils_I_set_get_variable_ext
+    ToolsUtil.set_variable 'teste_string', ""
+    ToolsUtil.set_variable 'teste_array', []
+    ToolsUtil.set_variable 'teste_hash', {}
+    ToolsUtil.set_variable_ext 'teste_string', "A"
+    ToolsUtil.set_variable_ext 'teste_array', "1"
+    ToolsUtil.set_variable_ext 'teste_hash', {:teste => 'teste'}
+    ToolsUtil.set_variable_ext 'teste_hash_error', []
+    assert_equal (ToolsUtil.get_variable 'teste_string'), 'A'
+    assert_equal (ToolsUtil.get_variable 'teste_array'), ['1']
+    assert_equal (ToolsUtil.get_variable 'teste_hash'), {:teste => 'teste'}
+    assert_nil (ToolsUtil.get_variable 'teste_hash_error')
+  end
+
+  def test_utils_K_get_variables
+    ToolsUtil.set_variable 'teste', 'A'
+    assert_equal ToolsUtil.get_variables.class, Array
+  end
+
+  def test_utils_L_get_plain_text
+    data = {
+      'k1' => 100,
+      'k2' => 'v2'
+    }
+    assert_equal (ToolsUtil.get_plain_text data), "{\n    \"k1\" => 100,\n    \"k2\" => \"v2\"\n}\n"
+    assert_equal (ToolsUtil.get_plain_text "TEST"), "\t\e[0;33;49mTEST\e[0m"
+    assert_equal (ToolsUtil.get_plain_text true), true
+    assert_nil (ToolsUtil.get_plain_text nil)
+  end
+
+  def test_utils_M_get_tools_variables
+    assert_equal Tools.root, (File.dirname __dir__)
+    assert_equal Tools.files, (File.join (File.dirname __dir__), 'lib/files')
+    assert_equal Tools.host, Socket.gethostname
+    assert_equal Tools.home, ENV['HOME']
+    assert_equal Tools.user, ENV['USER']
+    assert_equal Tools.pwd, ENV['PWD']
+    assert_equal Tools.ldap_pass, ENV['ldap_pass']
+    assert_equal Tools.ldap_user, ENV['ldap_user']
+    assert_equal Tools.gem_path, ENV['GEM_PATH']
+  end
+
+
+  # def test_utils_N_instance
+  #   mock = MiniTest::Mock.new
+  #   def mock.initialize  *args; true; end
+  #   ToolsUtil.stub :initialize, mock do
+  #     assert_equal (ToolsUtil.new), true
+  #   end
+  # end
+
+end