veritrans 2.1.2 → 2.4.0

data/spec/midtrans_rename_spec.rb

@@ -1,27 +0,0 @@
-describe Veritrans::Client do
-
-  before do
-    hide_const("Rails")
-    Midtrans.logger = Logger.new("/dev/null")
-    Midtrans.setup do
-      config.load_config "./spec/configs/real_key.yml"
-    end
-  end
-
-  it "should create alias constant for Midtrans" do
-    Midtrans.should == Veritrans
-  end
-
-  it "should work with Midtrans" do
-    VCR.use_cassette('midtrans_status') do
-      txn_result = Veritrans.charge("permata", transaction: { order_id: Time.now.to_s, gross_amount: 100_000 })
-      txn_result.success?.should == true
-      txn_result.status_message.should == "Success, PERMATA VA transaction is successful"
-
-      cancel_result = Midtrans.status(txn_result.order_id)
-      cancel_result.success?.should == true
-      cancel_result.status_message.should == "Success, transaction is found"
-    end
-  end
-
-end

data/spec/rails_plugin_spec.rb

@@ -1,281 +0,0 @@
-require 'fileutils'
-require 'open3'
-require 'shellwords'
-require 'socket'
-
-describe "Rails plugin", vcr: false do
-  include Capybara::DSL
-
-  MAIN_RAILS_VER = "5.0.0.1"
-  APP_DIR = "plugin_test"
-  PLUGIN_DIR = File.expand_path("..", File.dirname(__FILE__))
-
-  RAILS_VERSIONS = ["4.0.13", "4.1.16", "4.2.7.1", "5.0.0.1"]
-
-  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
-
-    stdout_str, stderr_str, status = Open3.capture3(full_cmd)
-
-    if status != 0
-      puts "CMD: #{full_cmd}"
-      puts "FAILED"
-      puts stderr_str
-
-      exit 1
-    end
-
-    #puts stdout_str
-
-    return stdout_str
-  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')
-    if response =~ /[^\d]#{rails_version}[^\d]/
-      return true
-    else
-      run_cmd("gem install rails -v #{rails_version} --no-ri --no-rdoc")
-    end
-  end
-
-  def generate_rails_app(rails_version)
-    gen = "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"
-    run_cmd(gen)
-
-    gemfile_content = "
-      source 'https://rubygems.org'
-
-      gem 'rails', '#{rails_version}'
-      gem 'sqlite3'
-      gem 'turbolinks'
-      gem 'jquery-rails'
-      gem 'veritrans', path: '#{PLUGIN_DIR}'
-    ".gsub(/^\s+/, '')
-
-    File.open("#{@app_abs_path}/Gemfile", "w") {|f| f.write(gemfile_content) }
-
-    Dir.chdir(@app_abs_path) do
-      run_cmd("bundle")
-    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.veritrans.co.id
-"
-
-    File.open("#{@app_abs_path}/config/veritrans.yml", "w") {|f| f.write(config_content) }
-  end
-
-  def run_rails_app
-    @rails_port = find_open_port
-
-    Bundler.with_clean_env do
-      ENV["RAILS_ENV"] = "development"
-      Dir.chdir(@app_abs_path) do
-        run_cmd("./bin/rails server -d -p #{@rails_port} --bind 127.0.0.1")
-      end
-    end
-
-    Capybara.app_host = "http://127.0.0.1:#{@rails_port}"
-
-    #puts "RAILS_DIR: #{@app_abs_path}"
-
-    failed = 0
-    while failed < 10
-      begin
-        run_cmd("curl #{Capybara.app_host}/payments/new > /dev/null")
-        break
-      rescue Object => error
-        failed += 1
-        p error
-        puts "Retry"
-        sleep 0.3
-      end
-    end
-
-    if failed == 10
-      puts `tail -100 #{@app_abs_path}/log/development.log`
-      raise Exception, "can not start rails server"
-    end
-  end
-
-  def stop_rails_app
-    Dir.chdir(@app_abs_path) do
-      if File.exist?("./tmp/pids/server.pid")
-        run_cmd("kill `cat tmp/pids/server.pid`")
-      end
-    end
-  end
-
-  def find_open_port
-    socket = Socket.new(:INET, :STREAM, 0)
-    socket.bind(Addrinfo.tcp("127.0.0.1", 0))
-    return 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
-        #puts "Path: #{current_path}"
-        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
-      # 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
-
-      if page.body !~ /transaction is successful/
-        puts page.body
-      end
-      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("Payment is securely processed by Veritrans")
-      #Capybara::Screenshot.screenshot_and_open_image
-
-      # 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
-
-      if result2 !~ /status: 200/
-        puts `tail -40 #{@app_abs_path}/log/development.log`
-      end
-
-      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
-end

data/spec/spec_helper.rb

@@ -1,61 +0,0 @@
-require 'bundler/setup'
-
-$:.push(File.expand_path("../../lib", __FILE__))
-
-require 'rspec'
-require 'veritrans'
-require 'veritrans/cli'
-require 'veritrans/events'
-require 'rails'
-require 'webmock/rspec'
-require 'vcr'
-
-require 'capybara/rspec'
-require 'capybara/poltergeist'
-require 'active_support/testing/stream'
-
-Capybara.register_driver :poltergeist do |app|
-  Capybara::Poltergeist::Driver.new(app,
-    # phantomjs don't much like ssl of cloudfront.net
-    phantomjs_options: ['--ignore-ssl-errors=yes', '--ssl-protocol=any'],
-    # logger: STDOUT
-  )
-end
-
-Capybara.configure do |config|
-  config.javascript_driver = :poltergeist
-  config.default_driver = :poltergeist
-  config.app_host = ""
-  config.run_server = false
-end
-
-GEM_ROOT = File.expand_path("../..", __FILE__)
-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
-
-RSpec.configure do |config|
-  config.mock_with :rspec
-
-  config.expect_with :rspec do |c|
-    c.syntax = [:should, :expect]
-  end
-
-  config.mock_with :rspec do |c|
-    c.syntax = [: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
-end

data/spec/veritrans_client_spec.rb

@@ -1,184 +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
-
-  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.veritrans.co.id: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 == "The requested resource is not found"
-
-    #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 == "The requested resource is not found"
-    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 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 == "The requested resource is not found"
-    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 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 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.veritrans.co.id"
-  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

data/spec/veritrans_events_spec.rb

@@ -1,72 +0,0 @@
-describe Veritrans do
-  include ActiveSupport::Testing::Stream
-
-  before do
-    stub_const("CONFIG", {})
-    Veritrans.logger = Logger.new(STDOUT)
-    Veritrans.file_logger = Logger.new(STDOUT)
-    Veritrans.setup do
-      config.load_yml "./example/veritrans.yml#development"
-    end
-  end
-
-  after do
-    if Veritrans.events.listeners
-      Veritrans.events.listeners.clear
-    end
-  end
-
-  JSON_RESPONSE = '{
-    "status_code": "200",
-    "status_message": "Success, transaction found",
-    "transaction_id": "b1cbcc66-5608-4af1-a3ed-0f152f9ed871",
-    "order_id": "testing-0.2703-1415600236",
-    "payment_type": "credit_card",
-    "transaction_time": "2014-11-10 13:17:33",
-    "transaction_status": "settlement",
-    "gross_amount": "30000.00",
-    "masked_card": "481111-1114",
-    "fraud_status": "accept",
-    "approval_code": "1415600254322",
-    "bank": "bni"
-  }'
-
-  DOUBLE_ENCODED_JSON_RESPONSE = JSON.dump(JSON_RESPONSE)
-
-  def stub_vt_status_response
-    stub_request(:any, /.*veritrans.*/).to_return(lambda {|request|
-      {status: 200, body: JSON_RESPONSE}
-    })
-  end
-
-  it "should work with single encoded json" do
-    Veritrans.events.subscribe('payment.success') do |payment|
-      @payment = payment
-    end
-
-    stub_vt_status_response
-
-    handler = Rack::MockRequest.new(Veritrans::Events.new)
-    silence_stream(STDOUT) do
-      handler.post("http://example.com/", input: JSON_RESPONSE)
-    end
-
-    @payment.order_id.should == "testing-0.2703-1415600236"
-  end
-
-  it "should work with double encoded json" do
-    Veritrans.events.subscribe('payment.success') do |payment|
-      @payment = payment
-    end
-
-    stub_vt_status_response
-
-    handler = Rack::MockRequest.new(Veritrans::Events.new)
-    silence_stream(STDOUT) do
-      handler.post("http://example.com/", input: DOUBLE_ENCODED_JSON_RESPONSE)
-    end
-
-    @payment.order_id.should == "testing-0.2703-1415600236"
-  end
-
-end