gmo_payment_gem 0.0.1

data/lib/gmo_payment/api_request.rb

@@ -0,0 +1,72 @@
+require 'uri'
+require 'net/http'
+require 'net/https'
+
+class GmoPayment::ApiRequest
+  DEFAULT_TIMEOUT = 30 # Seconds
+  ENCODE_PARAMS   = %w(CardNo SiteID SitePass ShopID ShopPass).freeze
+
+  def initialize(request_url, request_params, timeout)
+    @request_url    = request_url
+    @request_params = request_params
+    @time_out       = timeout || DEFAULT_TIMEOUT
+    @requester      = nil
+  end
+
+  def make_request(method = 'post')
+    host, path = split_base_url_and_path
+    @requester = init_http_request(host)
+    begin
+      @requester.start
+      response = if method.casecmp('post').zero?
+                   @requester.post(path, to_query_params(@request_params))
+                 else
+                   @requester.get(path, to_query_params(@request_params))
+                 end
+    ensure
+      @requester.finish
+    end
+    response
+  end
+
+  def params2log
+    encode_params(to_query_params(@request_params))
+  end
+
+  private
+
+  def split_base_url_and_path
+    uri = URI.parse(@request_url)
+    [uri.host, uri.path]
+  end
+
+  def init_http_request(host)
+    http              = Net::HTTP.new(host, 443) # SSL port
+    http.open_timeout = @time_out
+    http.read_timeout = @time_out
+    http.use_ssl      = true
+    http
+  end
+
+  def to_query_params(options = {})
+    str = ''
+    options.each { |k, v| str << "#{k}=#{v}&" }
+    str
+  end
+
+  # Encode params string to *** format
+  # Eg: CardNo=1234567890123 to CardNo=*********123
+  def encode_params(log_msg)
+    params_patterns = "(#{ENCODE_PARAMS.join('|')})=\\w+"
+    log_msg.gsub(Regexp.new(params_patterns)) { |match| hide_value(match).to_s }
+  end
+
+  # Hide all value if value length <= 10
+  # Otherwise show last 3 characters
+  def hide_value(param_n_value)
+    param, value = param_n_value.split('=')
+    v_hide       = '*' * value.length
+    v_hide << value[-3..-1] if value.length > 10
+    "#{param}=#{v_hide}"
+  end
+end

data/lib/gmo_payment/api_response.rb

@@ -0,0 +1,94 @@
+class GmoPayment::ApiResponse
+  RESPONSE_SUCCESS_CODE = [200, 201].freeze
+  SPLIT_CHARACTER       = '|'.freeze
+
+  def initialize(api_url, body, response_http_code)
+    @api_url              = api_url
+    @response_body        = body
+    @response_http_code   = response_http_code
+    @response_body_parsed = parse_response_content
+  end
+
+  def response_code
+    @response_http_code
+  end
+
+  def response_body(raw = false)
+    raw ? @response_body : @response_body_parsed
+  end
+
+  def error_codes
+    r_detail = response_body
+    r_detail.fetch(:ErrCode, '').split(SPLIT_CHARACTER)
+  end
+
+  def error_infos
+    r_detail = response_body
+    r_detail.fetch(:ErrInfo, '').split(SPLIT_CHARACTER)
+  end
+
+  def error_messages
+    error_infos.map do |e_code|
+      GmoPayment::ApiErrors.all.fetch(e_code, "UNKNOWN ERROR with code #{e_code}")
+    end
+  end
+
+  def full_messages
+    error_messages.join(' ')
+  end
+
+  def has_error?(error_info_code)
+    error_infos.include?(error_info_code)
+  end
+
+  def success?
+    if block_given?
+      yield(@api_url, @response_http_code, @response_body, @response_body_parsed)
+    else
+      r_detail      = response_body
+      pre_condition = RESPONSE_SUCCESS_CODE.include?(response_code) && !r_detail.key?(:ErrCode)
+      case @api_url
+      when GmoPayment::ApiUrls.all.fetch('MEMBER_REGISTER'),
+        GmoPayment::ApiUrls.all.fetch('MEMBER_DELETE'),
+        GmoPayment::ApiUrls.all.fetch('MEMBER_SEARCH')
+        pre_condition && r_detail.key?(:MemberID)
+      when GmoPayment::ApiUrls.all.fetch('CARD_SAVE_OR_UPDATE')
+        pre_condition && r_detail.key?(:CardSeq) && r_detail.key?(:CardNo)
+      when GmoPayment::ApiUrls.all.fetch('CARD_DELETE')
+        pre_condition && r_detail.key?(:CardSeq)
+      when GmoPayment::ApiUrls.all.fetch('TRANSACTION_REGISTER')
+        pre_condition && r_detail.key?(:AccessID) && r_detail.key?(:AccessPass)
+      when GmoPayment::ApiUrls.all.fetch('TRANSACTION_SUBMIT')
+        pre_condition && r_detail.key?(:TranID) && r_detail.key?(:CheckString)
+      when GmoPayment::ApiUrls.all.fetch('TRANSACTION_UPDATE')
+        pre_condition && r_detail.key?(:AccessID) && r_detail.key?(:AccessPass)
+      else
+        pre_condition
+      end
+    end
+  end
+
+  def response2log(raw = false)
+    response_body(raw)
+  end
+
+  def full_errors2log
+    full_messages
+  end
+
+  private
+
+  def parse_response_content
+    result = {}
+    return result unless @response_body && !@response_body.empty?
+    begin
+      @response_body.split('&').each do |key_value|
+        key, value         = key_value.split('=')
+        result[key.to_sym] = value
+      end
+      result
+    rescue
+      result
+    end
+  end
+end

data/lib/gmo_payment/api_urls.rb

@@ -0,0 +1,39 @@
+class GmoPayment::ApiUrls
+  class << self
+    attr_accessor :urls
+  end
+  @urls = {}
+
+  def self.all
+    if frozen?
+      urls
+    else
+      base_payment_url = GmoPayment::Configurations.all.fetch(:base_url)
+      basic_urls       = {
+        # Transaction API URL
+        'TRANSACTION_REGISTER'     => "#{base_payment_url}/EntryTran.idPass",
+        'TRANSACTION_SUBMIT'       => "#{base_payment_url}/ExecTran.idPass",
+        'TRANSACTION_UPDATE'       => "#{base_payment_url}/AlterTran.idPass",
+        'TRANSACTION_MONEY_CHANGE' => "#{base_payment_url}/ChangeTran.idPass",
+        'TRANSACTION_SEARCH'       => "#{base_payment_url}/SearchTrade.idPass",
+
+        # Member API URL
+        'MEMBER_REGISTER'          => "#{base_payment_url}/SaveMember.idPass",
+        'MEMBER_UPDATE'            => "#{base_payment_url}/UpdateMember.idPass",
+        'MEMBER_SEARCH'            => "#{base_payment_url}/SearchMember.idPass",
+        'MEMBER_DELETE'            => "#{base_payment_url}/DeleteMember.idPass",
+
+        # Credit card API URL
+        'CARD_SAVE_AFTER_TRADED'   => "#{base_payment_url}/TradedCard.idPass",
+        'CARD_SAVE_OR_UPDATE'      => "#{base_payment_url}/SaveCard.idPass",
+        'CARD_SEARCH'              => "#{base_payment_url}/SearchCard.idPass",
+        'CARD_DELETE'              => "#{base_payment_url}/DeleteCard.idPass"
+      }
+
+      more_urls = GmoPayment::Configurations.all.fetch(:more_urls, {})
+      self.urls = basic_urls.merge(more_urls)
+      freeze
+      urls
+    end
+  end
+end

data/lib/gmo_payment/configurations.rb

@@ -0,0 +1,14 @@
+class GmoPayment::Configurations
+  REQUIRED_CONFIG = [:base_url, :log_path, :shop_id, :shop_pass, :site_id, :site_pass].freeze
+  class << self
+    attr_accessor :all
+  end
+  @all = {}
+
+  def self.check_valid!(changeable_on_runtime = false)
+    freeze unless changeable_on_runtime
+    REQUIRED_CONFIG.each do |param|
+      raise GmoPayment::CustomError, "gmo_payment error: #{param} not set" if all.fetch(param, nil).nil?
+    end
+  end
+end

data/lib/gmo_payment/custom_error.rb

@@ -0,0 +1 @@
+class GmoPayment::CustomError < StandardError; end

data/lib/gmo_payment/logger.rb

@@ -0,0 +1,10 @@
+class GmoPayment::Logger
+  class << self
+    def write(msg)
+      log_path = GmoPayment::Configurations.all.fetch(:log_path)
+      File.open(log_path, 'a+') do |f|
+        f.write("#{Time.now} :: #{msg} \n")
+      end
+    end
+  end
+end

data/lib/gmo_payment.rb

@@ -0,0 +1,98 @@
+class GmoPayment
+  def initialize(options = {}, type_site = true, logger = nil)
+    @base_params = if type_site
+                     {
+                       SiteID:   GmoPayment::Configurations.all.fetch(:site_id),
+                       SitePass: GmoPayment::Configurations.all.fetch(:site_pass)
+                     }
+                   else
+                     {
+                       ShopID:   GmoPayment::Configurations.all.fetch(:shop_id),
+                       ShopPass: GmoPayment::Configurations.all.fetch(:shop_pass)
+                     }
+                   end
+    @time_out    = options.fetch(:time_out, nil)
+    @logger      = logger || GmoPayment::Logger
+  end
+
+  def register_member(params = {})
+    api_url = GmoPayment::ApiUrls.all.fetch('MEMBER_REGISTER')
+    call_api(api_url, params)
+  end
+
+  def delete_member(params = {})
+    api_url = GmoPayment::ApiUrls.all.fetch('MEMBER_DELETE')
+    call_api(api_url, params)
+  end
+
+  def search_member(params = {})
+    api_url = GmoPayment::ApiUrls.all.fetch('MEMBER_SEARCH')
+    call_api(api_url, params)
+  end
+
+  def save_card(params = {})
+    api_url = GmoPayment::ApiUrls.all.fetch('CARD_SAVE_OR_UPDATE')
+    call_api(api_url, params)
+  end
+
+  def delete_card(params = {})
+    api_url = GmoPayment::ApiUrls.all.fetch('CARD_DELETE')
+    call_api(api_url, params)
+  end
+
+  # Transaction normal flow
+  # Register > Submit with :JobCd = 'CAPTURE'
+  # Register > Submit > Confirm with :JobCd != 'CAPTURE'
+  def register_transaction(params = {})
+    api_url = GmoPayment::ApiUrls.all.fetch('TRANSACTION_REGISTER')
+    call_api(api_url, params)
+  end
+
+  def submit_transaction(params = {})
+    api_url = GmoPayment::ApiUrls.all.fetch('TRANSACTION_SUBMIT')
+    call_api(api_url, params)
+  end
+
+  def confirm_transaction(params = {})
+    api_url = GmoPayment::ApiUrls.all.fetch('TRANSACTION_UPDATE')
+    call_api(api_url, params)
+  end
+
+  def transaction_status(params = {})
+    api_url = GmoPayment::ApiUrls.all.fetch('TRANSACTION_SEARCH')
+    call_api(api_url, params)
+  end
+
+  protected
+
+  def call_api(api_url, params = {}, method = 'post')
+    params.merge!(@base_params)
+    request = GmoPayment::ApiRequest.new(api_url, params, @time_out)
+    write_log('---------- START REQUEST TO GMO PAYMENT --------')
+    write_log("REQUEST URL: --------- #{api_url}")
+    write_log("REQUEST PARAMS: ------ #{request.params2log}")
+    response_raw = request.make_request(method)
+    response     = GmoPayment::ApiResponse.new(api_url, response_raw.body, response_raw.code.to_i)
+    write_log("RESPONSE: ------------ HTTP #{response.response_code}: #{response.response2log}")
+    write_log("WITH ERRORS: --------- #{response.full_errors2log}")
+    write_log(%(----------- END REQUEST TO GMO PAYMENT --------\n))
+    response
+  rescue StandardError => e
+    write_log("gmo_payment INTERNAL ERROR: #{e.message} : #{e.backtrace[0, 5]}")
+    raise GmoPayment::CustomError, "gmo_payment error: #{e.message}"
+  end
+
+  private
+
+  def write_log(log_msg)
+    @logger.write(log_msg)
+  end
+end
+
+require 'gmo_payment/configurations'
+require 'gmo_payment/api_urls'
+require 'gmo_payment/api_errors'
+require 'gmo_payment/logger'
+require 'gmo_payment/api_request'
+require 'gmo_payment/api_response'
+require 'gmo_payment/custom_error'

data/test/helper.rb

@@ -0,0 +1,51 @@
+require 'webmock/test_unit'
+require 'gmo_payment'
+require 'gmo_payment/custom_error'
+require 'gmo_payment/configurations'
+
+def payment_base_url
+  'https://test-example.com/payment'
+end
+
+def stub_request_to_payment(res_status = 200, res_body = '')
+  stub_request(:any, /test-example.com\/payment/)
+    .with(headers: {
+            'Accept'          => '*/*',
+            'Accept-Encoding' => 'gzip;q=1.0,deflate;q=0.6,identity;q=0.3',
+            'User-Agent'      => 'Ruby'
+          })
+    .to_return(status: res_status, body: res_body, headers: {})
+end
+
+def stub_request_to_timeout
+  stub_request(:any, payment_base_url)
+    .with(headers: {
+            'Accept'          => '*/*',
+            'Accept-Encoding' => 'gzip;q=1.0,deflate;q=0.6,identity;q=0.3',
+            'User-Agent'      => 'Ruby'
+          })
+    .to_raise(GmoPayment::CustomError)
+end
+
+def basic_setting
+  {
+    site_id:   'site_id',
+    site_pass: 'site_id',
+    shop_id:   'site_id',
+    shop_pass: 'site_id',
+    log_path:  File.join(File.dirname(__FILE__), '/logs/test.log'),
+    base_url:  payment_base_url
+  }
+end
+
+def set_basic_config
+  GmoPayment::Configurations.all = basic_setting
+end
+
+def clear_config
+  GmoPayment::Configurations.all = {}
+end
+
+def set_more_configs(more_configs)
+  GmoPayment::Configurations.all = basic_setting.merge(more_configs)
+end

data/test/test_api_errors.rb

@@ -0,0 +1,40 @@
+require 'test/unit'
+require 'gmo_payment'
+require 'helper'
+
+class TestApiErrors < Test::Unit::TestCase
+  def test_no_more_errors
+    set_basic_config
+    obj_dup            = GmoPayment::ApiErrors.dup
+    obj_dup.all_errors = obj_dup.errors
+    assert_equal(GmoPayment::ApiErrors.errors.size,
+                 obj_dup.all.size)
+  end
+
+  def test_has_more_errors
+    more_errors = {
+      more_errors: { 'CE1' => 'CE1_VALUE', # New error
+                     'CE2' => 'CE2_VALUE' } # New error
+    }
+    set_more_configs(more_errors)
+    assert_equal(GmoPayment::ApiErrors.errors.size + 2,
+                 GmoPayment::ApiErrors.dup.all.size)
+    assert_equal('CE1_VALUE',
+                 GmoPayment::ApiErrors.all.fetch('CE1'))
+  end
+
+  def test_overwrite_errors
+    more_errors = {
+      more_errors: {
+        'NC2000001' => 'NC2000001_VALUE', # Existing error
+        'CE2'       => 'CE2_VALUE' # New error
+      }
+    }
+    set_more_configs(more_errors)
+    obj_dup = GmoPayment::ApiErrors.dup
+    assert_equal(GmoPayment::ApiErrors.errors.size + 1,
+                 obj_dup.all.size)
+    assert_equal('NC2000001_VALUE',
+                 obj_dup.all.fetch('NC2000001'))
+  end
+end

data/test/test_api_request.rb

@@ -0,0 +1,43 @@
+require 'test/unit'
+require 'gmo_payment'
+require 'helper'
+
+class TestApiRequest < Test::Unit::TestCase
+  def test_make_request_valid
+    url     = payment_base_url
+    params  = {}
+    timeout = 30 # Seconds
+    request = GmoPayment::ApiRequest.new(url, params, timeout)
+    stub_request_to_payment
+    response = request.make_request
+    assert_equal(true, response.is_a?(Net::HTTPOK))
+  end
+
+  def test_make_request_timeout
+    url     = payment_base_url
+    params  = {}
+    timeout = 30 # Seconds
+    request = GmoPayment::ApiRequest.new(url, params, timeout)
+    stub_request_to_timeout
+    begin
+      request.make_request
+    rescue => e
+      assert_equal(true, e.is_a?(GmoPayment::CustomError))
+    end
+  end
+
+  def test_params_has_been_hide
+    url           = payment_base_url
+    params        = {
+      ShopID:   'shop_id',
+      ShopPass: 'shop_pass',
+      SiteID:   'site_id',
+      SitePass: 'site_pass',
+      CardNo:   12_345_678_901_234
+    }
+    expect_params = 'ShopID=*******&ShopPass=*********&SiteID=*******&SitePass=*********&CardNo=**************234&'
+    timeout       = 30 # Seconds
+    request       = GmoPayment::ApiRequest.new(url, params, timeout)
+    assert_equal(expect_params, request.params2log)
+  end
+end

data/test/test_api_response.rb

@@ -0,0 +1,105 @@
+require 'test/unit'
+require 'gmo_payment'
+require 'helper'
+
+class TestApiResponse < Test::Unit::TestCase
+  def test_response_code
+    response = GmoPayment::ApiResponse.new(payment_base_url, '', 200)
+    assert_equal(200, response.response_code)
+  end
+
+  def test_response_body_raw
+    response_body = 'BODY RAW'
+    response      = GmoPayment::ApiResponse.new(payment_base_url, response_body, 200)
+    assert_equal(response_body, response.response_body(true))
+  end
+
+  def test_response_body_parsed
+    response_body      = 'something=123&somethingelse=456'
+    expect_parsed_body = {
+      something:     '123',
+      somethingelse: '456'
+    }
+    response = GmoPayment::ApiResponse.new(payment_base_url, response_body, 200)
+    assert_equal(expect_parsed_body, response.response_body)
+  end
+
+  def test_error_codes_and_infos
+    response_body    = 'ErrCode=123|456|789&ErrInfo=ErrInfo1|ErrInfo2'
+    expect_err_codes = %w(123 456 789)
+    expect_err_infos = %w(ErrInfo1 ErrInfo2)
+    response         = GmoPayment::ApiResponse.new(payment_base_url, response_body, 200)
+    assert_equal(expect_err_codes, response.error_codes)
+    assert_equal(expect_err_infos, response.error_infos)
+  end
+
+  def test_error_in_errors_list
+    response_body        = 'ErrCode=123|456|789&ErrInfo=E00000000|E01010001|E01010008'
+    expect_err_messages  = ['特になし',
+                            'ショップIDが指定されていません。',
+                            'ショップIDに半角英数字以外の文字が含まれているか、13文字を超えています。']
+    expect_full_messages = expect_err_messages.join(' ')
+    response             = GmoPayment::ApiResponse.new(payment_base_url, response_body, 200)
+    assert_equal(expect_err_messages, response.error_messages)
+    assert_equal(expect_full_messages, response.full_messages)
+    assert_equal(expect_full_messages, response.full_errors2log)
+  end
+
+  def test_error_not_in_errors_list
+    response_body        = 'ErrCode=123|456|789&ErrInfo=EXXX|EYYY|EZZZ'
+    expect_err_messages  = ['UNKNOWN ERROR with code EXXX',
+                            'UNKNOWN ERROR with code EYYY',
+                            'UNKNOWN ERROR with code EZZZ']
+    expect_full_messages = expect_err_messages.join(' ')
+    response             = GmoPayment::ApiResponse.new(payment_base_url, response_body, 200)
+    assert_equal(expect_err_messages, response.error_messages)
+    assert_equal(expect_full_messages, response.full_messages)
+    assert_equal(expect_full_messages, response.full_errors2log)
+  end
+
+  def test_no_error
+    response_body        = 'somthing=123&somethingelse=456'
+    expect_err_messages  = []
+    expect_full_messages = ''
+    response             = GmoPayment::ApiResponse.new(payment_base_url, response_body, 200)
+    assert_equal(expect_err_messages, response.error_messages)
+    assert_equal(expect_full_messages, response.full_messages)
+    assert_equal(expect_full_messages, response.full_errors2log)
+  end
+
+  def test_success_without_block
+    set_basic_config
+    api_url_key   = 'TRANSACTION_REGISTER'
+    api_url       = GmoPayment::ApiUrls.all.fetch(api_url_key)
+    response_body = 'AccessID=123&AccessPass=456'
+    response      = GmoPayment::ApiResponse.new(api_url, response_body, 200)
+    assert_equal(true, response.success?)
+  end
+
+  def test_success_with_block
+    set_basic_config
+    api_url_key   = 'TRANSACTION_REGISTER'
+    api_url       = GmoPayment::ApiUrls.all.fetch(api_url_key)
+    response_body = 'AccessID=123&AccessPass=456'
+    response      = GmoPayment::ApiResponse.new(api_url, response_body, 200)
+    assert_equal(true, response.success? { |_, _, _, _| true })
+  end
+
+  def test_success_fail_by_http_code
+    set_basic_config
+    api_url_key   = 'TRANSACTION_REGISTER'
+    api_url       = GmoPayment::ApiUrls.all.fetch(api_url_key)
+    response_body = 'AccessID=123&AccessPass=456'
+    response      = GmoPayment::ApiResponse.new(api_url, response_body, 400)
+    assert_equal(false, response.success?)
+  end
+
+  def test_success_fail_by_has_error
+    set_basic_config
+    api_url_key   = 'TRANSACTION_REGISTER'
+    api_url       = GmoPayment::ApiUrls.all.fetch(api_url_key)
+    response_body = 'ErrCode=123'
+    response      = GmoPayment::ApiResponse.new(api_url, response_body, 400)
+    assert_equal(false, response.success?)
+  end
+end

data/test/test_api_urls.rb

@@ -0,0 +1,21 @@
+require 'test/unit'
+require 'gmo_payment'
+require 'helper'
+
+class TestApiUrls < Test::Unit::TestCase
+  def test_all_with_no_more_url
+    set_basic_config
+    assert_equal(13, GmoPayment::ApiUrls.all.size)
+  end
+
+  def test_all_with_more_urls
+    more_urls = {
+      more_urls: {
+        'MORE_PAYMENT_URL1' => 'MORE_PAYMENT_URL1_VALUE',
+        'MORE_PAYMENT_URL2' => 'MORE_PAYMENT_URL2_VALUE'
+      }
+    }
+    set_more_configs(more_urls)
+    assert_equal(13 + 2, GmoPayment::ApiUrls.dup.all.size)
+  end
+end

data/test/test_configurations.rb

@@ -0,0 +1,20 @@
+require 'test/unit'
+require 'gmo_payment'
+require 'helper'
+
+class TestConfigurations < Test::Unit::TestCase
+  def test_check_valid_success
+    set_basic_config
+    assert_equal(GmoPayment::Configurations::REQUIRED_CONFIG, GmoPayment::Configurations.check_valid!(true))
+  end
+
+  def test_check_valid_fail
+    clear_config
+    begin
+      GmoPayment::Configurations.check_valid!(true)
+    rescue => e
+      assert_equal(true, e.is_a?(GmoPayment::CustomError))
+      assert_equal('gmo_payment error: base_url not set', e.message)
+    end
+  end
+end

data/test/test_gmo_payment.rb

@@ -0,0 +1,16 @@
+require 'test/unit'
+require 'gmo_payment'
+require 'helper'
+
+class TestGmoPayment < Test::Unit::TestCase
+  def test_public_methods
+    set_basic_config
+    gmo_payment = GmoPayment.new
+    api_methods = gmo_payment.public_methods(false)
+    stub_request_to_payment
+    api_methods.each do |api_call|
+      response = gmo_payment.public_send(api_call)
+      assert_equal(GmoPayment::ApiResponse, response.class)
+    end
+  end
+end

data/test/test_logger.rb

@@ -0,0 +1,26 @@
+require 'test/unit'
+require 'gmo_payment'
+require 'helper'
+
+class TestLogger < Test::Unit::TestCase
+  def test_write_log_success
+    set_basic_config
+    log_msg = 'this is a log'
+    GmoPayment::Logger.write(log_msg)
+    log_on_file = false
+    File.open(GmoPayment::Configurations.all.fetch(:log_path), 'r') do |f|
+      f.each_line { |line| log_on_file = true if line.index(log_msg).to_i >= 0 }
+    end
+    assert_equal(true, log_on_file)
+  end
+
+  def test_log_path_not_found
+    clear_config
+    log_msg = 'this is a log'
+    begin
+      GmoPayment::Logger.write(log_msg)
+    rescue => e
+      assert_equal(true, e.is_a?(KeyError))
+    end
+  end
+end