veritrans 2.3.0 → 2.4.0

data/spec/rails_plugin_spec.rb

@@ -1,317 +0,0 @@
-require 'fileutils'
-require 'open3'
-require 'shellwords'
-require 'socket'
-
-describe 'Rails plugin', vcr: false do
-  include Capybara::DSL
-
-  MAIN_RAILS_VER = '5.2.3'.freeze
-  APP_DIR = 'plugin_test'.freeze
-  PLUGIN_DIR = File.expand_path('..', File.dirname(__FILE__))
-
-  RAILS_VERSIONS = %w[4.2.11.1 5.0.7.2 5.1.7 5.2.3].freeze
-
-  before :all do
-    FileUtils.mkdir_p("#{PLUGIN_DIR}/tmp")
-    # Capybara::Screenshot.instance_variable_set(:@capybara_root, "#{PLUGIN_DIR}/tmp")
-  end
-
-  def capture_stdout(&block)
-    original_stdout = $stdout
-    $stdout = fake = StringIO.new
-    begin
-      yield
-    ensure
-      $stdout = original_stdout
-    end
-    fake.string
-  end
-
-  def run_cmd(cmd, cli_args = [])
-    full_cmd = ([cmd] + cli_args).join.strip
-
-    puts "RUN: #{full_cmd}" if ENV['DEBUG']
-
-    output, status = Open3.capture2e(full_cmd)
-
-    if status != 0
-      puts "CMD: #{full_cmd}"
-      puts 'FAILED'
-      puts output
-
-      exit 1
-    end
-    output
-  end
-
-  def install_rails_in_tmp(rails_version = MAIN_RAILS_VER)
-    @rails_dir = Dir.mktmpdir
-    @app_abs_path = "#{@rails_dir}/#{APP_DIR}"
-
-    Dir.chdir(@rails_dir) do
-      Bundler.with_clean_env do
-        ENV['RAILS_ENV'] = 'development'
-        find_or_install_rails(rails_version)
-        generate_rails_app(rails_version)
-        generate_plugin_things
-      end
-    end
-  end
-
-  def find_or_install_rails(rails_version)
-    response = run_cmd('gem list \^rails\$ -q')
-
-    return true if response =~ /[^\d]#{rails_version}[^\d]/
-
-    run_cmd("gem install rails -v #{rails_version}")
-  end
-
-  def generate_rails_app(rails_version)
-    gemfile_content = "
-      source 'https://rubygems.org'
-
-      gem 'rails', '#{rails_version}'
-      gem 'sqlite3', '~> 1.3.13'
-      gem 'turbolinks'
-      gem 'jquery-rails'
-      gem 'veritrans', path: '#{PLUGIN_DIR}'
-    ".gsub(/^\s+/, '')
-
-    File.open('./Gemfile', 'w') { |f| f.write(gemfile_content) }
-    run_cmd('bundle _1.17.3_')
-
-    extra_rails_args = []
-    if rails_version >= '5.2.0'
-      extra_rails_args << '--skip-bootsnap'
-    end
-
-    gen = "bundle exec rails _#{rails_version}_ new #{APP_DIR} -B -G --skip-spring -d sqlite3 --skip-turbolinks --skip-test-unit --skip-action-cable --no-rc --skip-puma --skip-listen #{extra_rails_args.join(' ')}"
-
-    run_cmd(gen)
-
-    File.open("#{@app_abs_path}/Gemfile", 'w') { |f| f.write(gemfile_content) }
-
-    Dir.chdir(@app_abs_path) do
-      run_cmd('bundle _1.17.3_')
-    end
-  end
-
-  def generate_plugin_things
-    Dir.chdir(@app_abs_path) do
-      run_cmd('rails g veritrans:install')
-      run_cmd('rails g veritrans:payment_form')
-    end
-
-    config_content = "
-development:
-  client_key: VT-client-NArmatJZqzsmTmzR
-  server_key: VT-server-9Htb-RxXkg7-7hznSCCjxvoY
-  api_host: https://api.sandbox.midtrans.com
-"
-
-    File.open("#{@app_abs_path}/config/veritrans.yml", 'w') { |f| f.write(config_content) }
-  end
-
-  def run_rails_app
-    @rails_port = find_open_port
-
-    server_cmd = "./bin/rails server -p #{@rails_port} -b 127.0.0.1"
-    server_env = { "RAILS_ENV" => 'development', "BUNDLE_GEMFILE" => @app_abs_path + '/Gemfile' }
-    spawn_opts = { chdir: @app_abs_path }
-    spawn_opts[%i[err out]] = '/dev/null' unless ENV['DEBUG']
-
-    Bundler.with_clean_env do
-      puts "RUN: #{server_cmd} #{spawn_opts}" if ENV['DEBUG']
-      @runner_pid = spawn(server_env, server_cmd, spawn_opts)
-      puts "Process running PID: #{@runner_pid}" if ENV['DEBUG']
-    end
-
-    Capybara.app_host = "http://127.0.0.1:#{@rails_port}"
-
-    # puts "RAILS_DIR: #{@app_abs_path}"
-
-    check_cmd = "curl #{Capybara.app_host}/payments/new"
-
-    failed = 0
-    while failed < 100
-      puts "Check if rails server UP (#{Capybara.app_host})" if ENV['DEBUG']
-      output, status = Open3.capture2e(check_cmd)
-      if status == 0 && output =~ /credit_card_number/
-        if ENV['DEBUG']
-          puts 'Server is running, output:'
-          puts output[0..300]
-        end
-        break
-      else
-        failed += 1
-        sleep 0.3
-      end
-    end
-
-    return if failed != 100
-
-    puts `tail -100 #{@app_abs_path}/log/development.log`
-    raise Exception, 'cannot start rails server'
-  end
-
-  def stop_rails_app
-    Dir.chdir(@app_abs_path) do
-      run_cmd('kill `cat tmp/pids/server.pid`') if File.exist?('./tmp/pids/server.pid')
-    end
-  end
-
-  def find_open_port
-    socket = Socket.new(:INET, :STREAM, 0)
-    socket.bind(Addrinfo.tcp('127.0.0.1', 0))
-    socket.local_address.ip_port
-  ensure
-    socket.close
-  end
-
-  after do
-    stop_rails_app
-    FileUtils.remove_entry_secure(@rails_dir) if @rails_dir
-  end
-
-  def submit_payment_form(card_number)
-    # CREATE PAYMENT 1
-    visit '/payments/new'
-
-    fill_in 'credit_card_number', with: card_number
-    click_button 'Pay via VT-Direct'
-    puts 'Clicked Pay'
-
-    # Waiting for get token request in javascript...
-    Timeout.timeout(60.seconds) do
-      loop do
-        break if current_path != '/payments/new'
-
-        sleep 1
-      end
-    end
-
-    Timeout.timeout(10.seconds) do
-      loop do
-        break if page.body =~ /<body>/
-
-        sleep 0.1
-      end
-    end
-  end
-
-  RAILS_VERSIONS.each_with_index do |rails_version, spec_index|
-    next if rails_version.start_with?('5') && RUBY_VERSION < '2.2.2'
-
-    it "should tests plugin (Rails #{rails_version})" do
-      puts "Testing with Rails #{rails_version} and Ruby #{RUBY_VERSION}"
-      # PREPARE APP
-      install_rails_in_tmp(rails_version)
-      run_rails_app
-
-      card_numbers = [
-        '5481 1611 1111 1081',
-        '5410 1111 1111 1116',
-        '4011 1111 1111 1112',
-        '4411 1111 1111 1118',
-        '4811 1111 1111 1114',
-        '3528 6647 7942 9687',
-        '3528 2033 2456 4357'
-      ]
-      spec_index = (spec_index + RUBY_VERSION.gsub(/[^\d]/, '').to_i) % card_numbers.size
-      card_number = card_numbers[spec_index]
-
-      submit_payment_form(card_number)
-
-      if page.body =~ /too many transactions/
-        puts '!!!!'
-        puts 'Merchant has sent too many transactions to the same card number'
-        puts '!!!!'
-        # page.should have_content("Merchant has sent too many transactions to the same card number")
-        puts 'Wait 10 seconds and retry'
-        sleep 10
-        submit_payment_form(card_number)
-      end
-
-      puts page.body if page.body !~ /transaction is successful/
-
-      page.should have_content('Success, Credit Card transaction is successful')
-
-      order_info = ActiveSupport::JSON.decode(find('pre').text)
-      puts "Order Info: #{order_info}"
-      created_order_id = order_info['order_id']
-      # Capybara::Screenshot.screenshot_and_open_image
-
-      # CREATE PAYMENT 2
-      visit '/payments/new'
-      click_link 'Pay via VT-Web'
-
-      page.should have_content('ATM/Bank Transfer')
-
-      # TEST CALLBACK FOR WRONG DATA
-      stub_const("CONFIG", {})
-      result1 = capture_stdout do
-        Veritrans::CLI.test_webhook(["#{Capybara.app_host}/payments/receive_webhook"])
-      end
-
-      result1.should =~ /status: 404/
-
-      # TEST CALLBACK FOR CORRECT DATA
-      stub_const('CONFIG', order: created_order_id, config_path: "#{@app_abs_path}/config/veritrans.yml")
-      result2 = capture_stdout do
-        Veritrans::CLI.test_webhook(["#{Capybara.app_host}/payments/receive_webhook"])
-      end
-
-      puts `tail -40 #{@app_abs_path}/log/development.log` if result2 !~ /status: 200/
-
-      result2.should =~ /status: 200/
-      result2.should =~ /body: ok/
-    end
-  end
-
-  it 'should print message if running in staging' do
-    # PREPARE APP
-    install_rails_in_tmp
-    File.open("#{@app_abs_path}/config/database.yml", 'a') { |f|
-      f.puts
-      f.puts('staging:')
-      f.puts('  adapter: sqlite3')
-      f.puts("  database: ':memory:'")
-    }
-
-    Bundler.with_clean_env do
-      ENV['RAILS_ENV'] = 'staging'
-      Dir.chdir(@app_abs_path) do
-        stdout_str, stderr_str, status = Open3.capture3(%(./bin/rails r 'p :started'))
-        stderr_str.should include('Veritrans: Can not find section "staging"')
-        stderr_str.should include('Available sections: ["development"]')
-        stderr_str.should include('Veritrans: Using first section "development"')
-      end
-    end
-  end
-
-  it 'should create logs for log/veritrans.log' do
-    install_rails_in_tmp
-    FileUtils.rm_rf(@app_abs_path + '/log')
-    File.open(@app_abs_path + '/config/application.rb', 'a') do |f|
-      f.write %{
-        logger = ActiveSupport::Logger.new(STDOUT)
-        Rails.application.config.logger = ActiveSupport::TaggedLogging.new(logger)
-      }
-    end
-    run_rails_app
-
-    response = Excon.post(
-      "#{Capybara.app_host}/payments/receive_webhook",
-      body: { transaction_id: '111' }.to_json,
-      headers: { 'Content-Type' => 'application/json' }
-    )
-    expect(response.body).to eq 'error'
-    expect(response.status).to eq 404
-
-    expect(File.exist?(@app_abs_path + '/log/development.log')).to eq false
-    expect(File.exist?(@app_abs_path + '/log/veritrans.log')).to eq true
-
-    File.read(@app_abs_path + '/log/veritrans.log').should include('Callback verification failed for order')
-  end
-end

data/spec/spec_helper.rb

@@ -1,71 +0,0 @@
-require 'bundler/setup'
-
-$LOAD_PATH.push(File.expand_path('../lib', __dir__))
-
-require 'rspec'
-require 'veritrans'
-require 'veritrans/cli'
-require 'veritrans/events'
-require 'rails'
-require 'webmock/rspec'
-require 'vcr'
-require 'timecop'
-
-require 'capybara/rspec'
-require 'capybara-screenshot/rspec'
-require 'capybara/poltergeist'
-require 'active_support/testing/stream'
-
-Capybara.register_driver :poltergeist do |app|
-  Capybara::Poltergeist::Driver.new(
-    app,
-    js_errors: false,
-    # phantomjs don't much like ssl of cloudfront.net
-    phantomjs_options: %w[--ignore-ssl-errors=yes --ssl-protocol=any]
-    # logger: STDOUT
-  )
-end
-
-Capybara.configure do |config|
-  config.javascript_driver = :poltergeist
-  config.default_driver = :poltergeist
-  config.run_server = false
-end
-
-GEM_ROOT = File.expand_path('..', __dir__)
-ENV['RAILS_ENV'] = 'development'
-
-VCR.configure do |c|
-  c.cassette_library_dir = 'spec/fixtures'
-  c.hook_into :webmock # or :fakeweb
-  # c.debug_logger = STDOUT
-end
-
-module SpecHelper
-  def show_image
-    Capybara::Screenshot.screenshot_and_open_image
-  end
-end
-
-RSpec.configure do |config|
-  config.mock_with :rspec
-
-  config.expect_with :rspec do |c|
-    c.syntax = %i[should expect]
-  end
-
-  config.mock_with :rspec do |c|
-    c.syntax = %i[should expect]
-  end
-
-  config.around(:each) do |example|
-    if example.metadata[:vcr] === false
-      WebMock.allow_net_connect!
-      VCR.turned_off { example.run }
-      WebMock.disable_net_connect!
-    else
-      example.run
-    end
-  end
-  config.include(SpecHelper)
-end

data/spec/veritrans_client_spec.rb

@@ -1,235 +0,0 @@
-describe Veritrans::Client do
-
-  before do
-    hide_const("Rails")
-    Veritrans.logger = Logger.new("/dev/null")
-    Veritrans.setup do
-      config.load_config "./spec/configs/real_key.yml"
-    end
-  end
-
-  def test_card_data
-    {
-      card_number: 4811_1111_1111_1114,
-      card_cvv: 123,
-      card_exp_month: 1,
-      card_exp_year: Time.now.year + 1
-    }
-  end
-
-  it "should use Veritrans.http_options", vcr: false do
-    Veritrans::Config.stub(:http_options) do
-      { omit_default_port: true }
-    end
-
-    api_request = nil
-    stub_request(:any, /.*/).to_return(lambda { |request|
-      api_request = request
-      { body: request.body }
-    })
-
-    result = Veritrans.request_with_logging(:get, Veritrans.config.api_host + "/ping", {})
-
-    api_request.headers["Host"].should == "api.sandbox.midtrans.com:443"
-  end
-
-  it "should use Veritrans.http_options to attach hedaers", vcr: false do
-    Veritrans.config.stub(:http_options) do
-      { headers: { "X-Rspec" => "ok" } }
-    end
-
-    api_request = nil
-    stub_request(:any, /.*/).to_return(lambda { |request|
-      api_request = request
-      { body: request.body }
-    })
-
-    result = Veritrans.request_with_logging(:get, Veritrans.config.api_host + "/ping", {})
-
-    api_request.headers["X-Rspec"].should == "ok"
-  end
-
-  it "should be able to create other instance of client" do
-    #Veritrans.logger = Logger.new(STDOUT)
-
-    VCR.configure do |c|
-      c.allow_http_connections_when_no_cassette = true
-    end
-
-    other_client = Veritrans.new(
-      server_key: "69b61a1b-b0b1-450b-a697-37109dbbecb0",
-      logger: Logger.new("/dev/null")
-    ) # M000937
-
-    result = Veritrans.charge(
-      payment_type: "mandiri_clickpay",
-      transaction_details: {
-        gross_amount: 10_000,
-        order_id: Time.now.to_s
-      },
-      mandiri_clickpay: {
-        card_number: "4111 1111 1111 1111".gsub(/\s/, ''),
-        input3: "%05d" % (rand * 100000).to_i,
-        input2: 10000,
-        input1: "1" * 10,
-        token: "000000"
-      },
-    )
-
-    #p result.request_options
-
-    other_result = other_client.status(result.transaction_id)
-
-    other_result.status_code.should == 404
-
-    other_result.status_message.should == "Transaction doesn't exist."
-
-    #p other_result.request_options
-
-    VCR.configure do |c|
-      c.allow_http_connections_when_no_cassette = true
-    end
-  end
-
-  it "should send charge vt-web request" do
-    VCR.use_cassette('charge_vtweb') do
-      result = Veritrans.charge('vtweb', transaction: { order_id: Time.now.to_s, gross_amount: 100_000 })
-
-      result.status_message.should == "OK, success do VTWeb transaction, please go to redirect_url"
-      result.success?.should == true
-      result.redirect_url.should be_present
-    end
-  end
-
-  it "should send charge vt-web request" do
-    VCR.use_cassette('charge_direct') do
-      result = Veritrans.charge("permata", transaction: { order_id: Time.now.to_s, gross_amount: 100_000 })
-
-      result.status_message.should == "Success, PERMATA VA transaction is successful"
-      result.success?.should == true
-      result.permata_va_number.should be_present
-    end
-  end
-
-  it "should send status request" do
-    VCR.use_cassette('status_fail') do
-      result = Veritrans.status("not-exists")
-      result.success?.should == false
-      result.status_message.should == "Transaction doesn't exist."
-    end
-  end
-
-  it "should send status request and get response" do
-    VCR.use_cassette('status_success') do
-      result_charge = Veritrans.charge('permata', transaction: { order_id: Time.now.to_i, gross_amount: 100_000 })
-      result = Veritrans.status(result_charge.order_id)
-      result.success?.should == true
-      result.status_message.should == "Success, transaction is found"
-      result.transaction_status.should == "pending"
-    end
-  end
-
-  it "should send status request and get response" do
-    VCR.use_cassette('cancel_failed') do
-      result = Veritrans.cancel("not-exists")
-      result.success?.should == false
-      result.status_message.should == "Transaction doesn't exist."
-    end
-  end
-
-  it "should send status request and get response" do
-    VCR.use_cassette('cancel_success') do
-      result_charge = Veritrans.charge('permata', transaction: { order_id: Time.now.to_i, gross_amount: 100_000 })
-      result = Veritrans.cancel(result_charge.order_id)
-      result.success?.should == true
-      result.status_message.should == "Success, transaction is canceled"
-      result.transaction_status.should == "cancel"
-    end
-  end
-
-  it "should send approve request" do
-    VCR.use_cassette('approve_failed') do
-      result = Veritrans.cancel("not-exists")
-      result.success?.should == false
-      result.status_message.should == "The requested resource is not found"
-    end
-  end
-
-  it 'should get token for testing' do
-    VCR.use_cassette('test_token') do
-      result = Veritrans.test_token(test_card_data)
-      result.should be_a_kind_of(String)
-    end
-  end
-
-  # Can only refund after it has been settled after one day
-  it 'should send refund request' do
-    VCR.use_cassette('refund_failed') do
-      result = Veritrans.refund('1415110696')
-      result.success?.should == false
-      result.status_message.should == 'Merchant cannot modify the status of the transaction'
-    end
-  end
-
-  it "should send capture request" do
-    VCR.use_cassette('capture_failed') do
-      result = Veritrans.capture("not-exists", 1000)
-      result.success?.should == false
-      result.status_message.should == "The requested resource is not found"
-    end
-  end
-
-  it 'should send deny request' do
-    VCR.use_cassette('deny_failed') do
-      Timecop.freeze(Time.utc(2019, 4, 1)) do
-        order_id = Time.now.to_i.to_s
-
-        charge_result = Veritrans.charge(
-          payment_type: 'credit_card',
-          credit_card: {
-            token_id: Veritrans.test_token(test_card_data)
-          },
-          transaction_details: {
-            order_id: order_id,
-            gross_amount: 3000
-          }
-        )
-
-        charge_result.status_message.should == "Success, Credit Card transaction is successful"
-
-        result = Veritrans.deny(order_id)
-        result.success?.should == false
-        result.status_message.should == 'Transaction status cannot be updated.'
-      end
-    end
-  end
-
-  it "should send expire request" do
-    VCR.use_cassette('expire_success', record: :once) do
-      result = Veritrans.expire("af3fb136-c405-4103-9a36-5a6a9e2855a9")
-      result.success?.should == true
-      result.status_message.should == "Success, transaction has expired"
-    end
-  end
-
-  it "should send expire request" do
-    VCR.use_cassette('expire_failed', record: :once) do
-      result = Veritrans.expire("not-exists")
-      result.success?.should == false
-      result.status_message.should == "The requested resource is not found"
-    end
-  end
-
-  it "should handle network exceptions", vcr: false do
-    Excon::Connection.any_instance.stub(:send) do
-      raise Excon::Errors::SocketError, Excon::Errors::Error.new("testing exception")
-    end
-
-    result = Veritrans.expire("not-exists")
-    result.status.should == "500"
-    result.data.should == {
-      status_code: "500",
-      status_message: "Internal server error, no response from backend. Try again later"
-    }
-  end
-end

data/spec/veritrans_config_spec.rb

@@ -1,70 +0,0 @@
-describe Veritrans::Config do
-
-  before do
-    hide_const("Rails")
-    hide_const("ENV")
-  end
-
-  it "should set Veritras as self inside config block" do
-    Veritrans.config do
-      self.should == Veritrans.instance
-    end
-  end
-
-  it "should have sandbox api_host by defualt" do
-    Veritrans.config.api_host.should == "https://api.sandbox.midtrans.com"
-  end
-
-  it "should set client key and server key" do
-    Veritrans.config do
-      config.client_key = "kk-1"
-      config.server_key = "sk-1"
-    end
-
-    Veritrans.config.client_key.should == "kk-1"
-    Veritrans.config.server_key.should == "sk-1"
-  end
-
-  it "should load config" do
-    data = Veritrans.config.load_config("./spec/configs/veritrans_flat.yml")
-    data.should == {"client_key" => "flat_client_key", "server_key" => "flat_server_key"}
-  end
-
-  it "should load config according to hash" do
-    data = Veritrans.config.load_config("./spec/configs/veritrans.yml#development")
-    data.should == {"client_key" => "spec_client_key", "server_key" => "spec_server_key"}
-  end
-
-  it "should load config for Rails.env" do
-    stub_const("Rails", Class.new {
-      def self.env
-        "test"
-      end
-    })
-
-    data = Veritrans.config.load_config("./spec/configs/veritrans.yml")
-    data.should == {"client_key" => "test_client_key", "server_key" => "test_server_key"}
-  end
-
-  it "should load config and render erb lines" do
-    stub_const('ENV', {
-      'CLIENT_KEY' => 'test_client_key',
-      'SERVER_KEY' => 'test_server_key'
-    })
-
-    data = Veritrans.config.load_config("./spec/configs/veritrans_with_erb.yml")
-    data.should == {"client_key" => "test_client_key", "server_key" => "test_server_key"}
-  end
-
-  it "should validate http_params type" do
-    expect {
-      Veritrans.config.http_options = nil
-    }.to raise_error(ArgumentError, "http_options should be a hash")
-  end
-
-  it "should validate http_params type" do
-    expect {
-      Veritrans.config.http_options = {foo: "bar", tcp_nodelay: true}
-    }.to raise_error(ArgumentError, /http_options contain unsupported keys: \[:foo\]/)
-  end
-end