payneteasy-payneteasyapi 0.1.0

data/test/paynet_easy/paynet_easy_api/callback/paynet_easy_callback_test.rb

@@ -0,0 +1,101 @@
+require_relative './callback_test_prototype'
+require 'callback/paynet_easy_callback'
+
+module PaynetEasy::PaynetEasyApi::Callback
+  class PaynetEasyCallbackTest < Test::Unit::TestCase
+    include CallbackTestPrototype
+
+    def test_process_callback_approved
+      [
+        {
+          'type'              => 'sale',
+          'status'            => 'approved',
+          'amount'            =>  0.99,
+          'orderid'           =>  PAYNET_ID,
+          'merchant_order'    =>  CLIENT_ID,
+          'client_orderid'    =>  CLIENT_ID,
+        }
+      ].each do |callback|
+        assert_process_callback_approved callback
+      end
+    end
+
+    alias :callback_test_prototype_assert_process_callback_approved :assert_process_callback_approved
+
+    def assert_process_callback_approved(callback)
+      payment_transaction, callback_response = callback_test_prototype_assert_process_callback_approved callback
+
+      assert_equal PaymentTransaction::PROCESSOR_CALLBACK, payment_transaction.processor_type
+      assert_equal callback_response.type, payment_transaction.processor_name
+
+      [payment_transaction, callback_response]
+    end
+
+    def test_process_callback_declined
+      [
+        {
+          'type'              => 'sale',
+          'status'            => 'declined',
+          'amount'            =>  0.99,
+          'orderid'           =>  PAYNET_ID,
+          'merchant_order'    =>  CLIENT_ID,
+          'client_orderid'    =>  CLIENT_ID,
+        },
+        {
+          'type'              => 'sale',
+          'status'            => 'filtered',
+          'amount'            =>  0.99,
+          'orderid'           =>  PAYNET_ID,
+          'merchant_order'    =>  CLIENT_ID,
+          'client_orderid'    =>  CLIENT_ID,
+        }
+      ].each do |callback|
+        assert_process_callback_declined callback
+      end
+    end
+
+    def test_process_callback_error
+      [
+        {
+          'type'              => 'sale',
+          'status'            => 'error',
+          'amount'            =>  0.99,
+          'orderid'           =>  PAYNET_ID,
+          'merchant_order'    =>  CLIENT_ID,
+          'client_orderid'    =>  CLIENT_ID,
+          'error_message'     => 'test type error message',
+          'error_code'        =>  5
+        }
+      ].each do |callback|
+        assert_process_callback_error callback
+      end
+    end
+
+    def test_process_callback_with_not_new_transaction
+      payment_transaction = payment_transaction()
+      payment_transaction.status = PaymentTransaction::STATUS_PROCESSING
+
+      callback_response = CallbackResponse.new(
+      [
+          'status'            => 'approved',
+          'amount'            =>  0.99,
+          'orderid'           =>  PAYNET_ID,
+          'merchant_order'    =>  CLIENT_ID,
+          'client_orderid'    =>  CLIENT_ID,
+      ])
+
+      sign_callback callback_response
+
+      assert_raise ValidationError, 'Only new payment transaction can be processed' do
+        callback_processor.process_callback payment_transaction, callback_response
+      end
+    end
+
+    protected
+
+    # @return   [PaynetEasyCallback]
+    def callback_processor
+      PaynetEasyCallback.new 'sale'
+    end
+  end
+end

data/test/paynet_easy/paynet_easy_api/fake.rb

@@ -0,0 +1,71 @@
+require 'paynet_easy_api'
+require 'payment_data/payment_transaction'
+require 'query/query_factory'
+require 'query/prototype/query'
+require 'transport/gateway_client'
+require 'callback/callback_prototype'
+require 'callback/callback_factory'
+
+module PaynetEasy::PaynetEasyApi
+  module Fake
+    include PaynetEasy::PaynetEasyApi::PaymentData
+    include PaynetEasy::PaynetEasyApi::Transport
+    include PaynetEasy::PaynetEasyApi::Query
+    include PaynetEasy::PaynetEasyApi::Callback
+
+    class FakeQueryFactory < QueryFactory
+      attr_writer :query
+
+      def query(api_query_name)
+        @query
+      end
+    end
+
+    class FakeGatewayClient < GatewayClient
+      attr_accessor :request
+      attr_accessor :response
+
+      def make_request(request)
+        self.request = request
+        response()
+      end
+    end
+
+    class FakeCallbackFactory < CallbackFactory
+      attr_writer :callback
+
+      def callback(callback_type)
+        @callback
+      end
+    end
+
+    class FakeQuery < Prototype::Query
+      attr_accessor :request
+
+      def create_request(payment_transaction)
+        request()
+      end
+
+      def process_response(payment_transaction, response)
+        if response.approved?
+          payment_transaction.status = PaymentTransaction::STATUS_APPROVED
+        end
+
+        response
+      end
+    end
+
+    class ExceptionQuery < FakeQuery
+      def process_response(payment_transaction, response)
+        raise RuntimeError, 'Process response error'
+      end
+    end
+
+    class FakeCallback < CallbackPrototype
+      def process_callback(payment_transaction, callback_response)
+        payment_transaction.status = PaymentTransaction::STATUS_APPROVED
+        callback_response
+      end
+    end
+  end
+end

data/test/paynet_easy/paynet_easy_api/payment_processor_test.rb

@@ -0,0 +1,255 @@
+require 'test/unit'
+require 'paynet_easy_api'
+require 'payment_processor'
+require 'payment_data/payment_transaction'
+require 'payment_data/payment'
+require 'payment_data/customer'
+require 'payment_data/billing_address'
+require 'payment_data/query_config'
+require 'transport/response'
+require 'transport/callback_response'
+require_relative './fake'
+
+module PaynetEasy::PaynetEasyApi
+  class PaymentProcessorTest < Test::Unit::TestCase
+    include PaynetEasy::PaynetEasyApi::PaymentData
+    include PaynetEasy::PaynetEasyApi::Transport
+    include PaynetEasy::PaynetEasyApi::Query
+    include PaynetEasy::PaynetEasyApi::Callback
+    include PaynetEasy::PaynetEasyApi::Fake
+
+    def setup
+      @object                 = PaymentProcessor.new
+      @fake_query_factory     = FakeQueryFactory.new
+      @fake_callback_factory  = FakeCallbackFactory.new
+      @fake_gateway_client    = FakeGatewayClient.new
+    end
+
+    def test_execute_query
+      [
+        [
+          'status',
+          {
+            'status'            => 'approved',
+            'type'              => 'status-response',
+            'paynet-order-id'   => '_',
+            'merchant-order-id' => '_',
+            'serial-number'     => '_'
+          },
+          PaymentProcessor::HANDLER_FINISH_PROCESSING
+        ],
+        [
+          'sale-form',
+          {
+            'redirect-url'      => 'http://example.com',
+            'type'              => 'async-form-response',
+            'paynet-order-id'   => '_',
+            'merchant-order-id' => '_',
+            'serial-number'     => '_'
+          },
+          PaymentProcessor::HANDLER_REDIRECT
+        ],
+        [
+          'status',
+          {
+            'html'              => '<html></html>',
+            'type'              => 'status-response',
+            'paynet-order-id'   => '_',
+            'merchant-order-id' => '_',
+            'serial-number'     => '_'
+          },
+          PaymentProcessor::HANDLER_SHOW_HTML
+        ],
+        [
+          'status',
+          {
+            'status'            => 'processing',
+            'type'              => 'status-response',
+            'paynet-order-id'   => '_',
+            'merchant-order-id' => '_',
+            'serial-number'     => '_'
+          },
+          PaymentProcessor::HANDLER_STATUS_UPDATE
+        ]
+      ].each do |query_name, response_data, handler_name|
+        assert_execute_query query_name, response_data, handler_name
+      end
+    end
+
+    def assert_execute_query(query_name, response_data, handler_name)
+      handler_called = false
+      handler = ->(*args){handler_called = true}
+
+      @fake_gateway_client.response = Response.new response_data
+      @object.gateway_client = @fake_gateway_client
+      @object.set_handler handler_name, &handler
+
+      assert_not_nil @object.execute_query(query_name, payment_transaction)
+      assert_true handler_called, "For query #{query_name} and handler #{handler_name}"
+    end
+
+    def test_execute_query_without_exception_handler
+      assert_raise_kind_of Exception do
+        @object.execute_query 'sale', PaymentTransaction.new
+      end
+    end
+
+    def test_execute_query_with_exception_on_create_request
+      handler_called = false
+      handler = ->(*args){handler_called = true}
+
+      @object.set_handler PaymentProcessor::HANDLER_CATCH_EXCEPTION, &handler
+      @object.execute_query 'sale', PaymentTransaction.new
+
+      assert_true handler_called
+    end
+
+    def test_execute_query_with_exception_on_process_response
+      handler_called = false
+      handler = ->(*args){handler_called = true}
+
+      exception_query               = ExceptionQuery.new 'exception'
+      exception_query.request       = Request.new
+      @fake_query_factory.query     = exception_query
+      @fake_gateway_client.response = Response.new
+
+      @object.gateway_client = @fake_gateway_client
+      @object.query_factory  = @fake_query_factory
+      @object.set_handler PaymentProcessor::HANDLER_CATCH_EXCEPTION, &handler
+
+      @object.execute_query 'exception', PaymentTransaction.new
+
+      assert_true handler_called
+    end
+
+    def test_process_customer_return
+      callback_response = CallbackResponse.new(
+      {
+        'status'            => 'approved',
+        'orderid'           => '_',
+        'merchant_order'    => '_',
+        'client_orderid'    => '_',
+        'control'           => '2c84ae87d73fa3dc116b3203e8bb1c133eed829d'
+      })
+
+      payment_transaction = payment_transaction()
+      payment_transaction.status = PaymentTransaction::STATUS_PROCESSING
+
+      handler_called = false
+      handler = ->(*args){handler_called = true}
+
+      @object.set_handler PaymentProcessor::HANDLER_FINISH_PROCESSING, &handler
+
+      assert_not_nil @object.process_customer_return callback_response, payment_transaction
+      assert_true handler_called
+    end
+
+    def test_process_paynet_easy_callback
+      handler_called = false
+      handler = ->(*args){handler_called = true}
+
+      @fake_callback_factory.callback = FakeCallback.new 'fake'
+      @object.callback_factory        = @fake_callback_factory
+      @object.set_handler PaymentProcessor::HANDLER_FINISH_PROCESSING, &handler
+
+      assert_not_nil @object.process_paynet_easy_callback CallbackResponse.new({'type' => 'fake'}), payment_transaction
+      assert_true handler_called
+    end
+
+    def test_process_callback_on_finished_payment
+      handler_called = false
+      handler = ->(*args){handler_called = true}
+
+      @fake_callback_factory.callback = FakeCallback.new 'fake'
+      @object.callback_factory        = @fake_callback_factory
+      @object.set_handler PaymentProcessor::HANDLER_FINISH_PROCESSING, &handler
+
+      @object.process_paynet_easy_callback CallbackResponse.new({'type' => 'fake'}), payment_transaction
+      assert_true handler_called
+    end
+
+    def test_process_paynet_easy_callback_with_exception
+      handler_called = false
+      handler = ->(*args){handler_called = true}
+
+      @object.set_handler PaymentProcessor::HANDLER_CATCH_EXCEPTION, &handler
+      @object.process_paynet_easy_callback CallbackResponse.new({'type' => 'sale'}), PaymentTransaction.new
+
+      assert_true handler_called
+    end
+
+    def test_handlers
+      @object.set_handlers(
+      {
+        PaymentProcessor::HANDLER_SAVE_CHANGES  => ->(*args){},
+        PaymentProcessor::HANDLER_SHOW_HTML     => ->(*args){}
+      })
+
+      assert_equal 2, @object.instance_variable_get(:@handlers).length
+      assert_true @object.send(:has_handler?, PaymentProcessor::HANDLER_SAVE_CHANGES)
+      assert_true @object.send(:has_handler?, PaymentProcessor::HANDLER_SHOW_HTML)
+
+      @object.remove_handler PaymentProcessor::HANDLER_SAVE_CHANGES
+
+      assert_equal 1, @object.instance_variable_get(:@handlers).length
+      assert_false @object.send(:has_handler?, PaymentProcessor::HANDLER_SAVE_CHANGES)
+      assert_true @object.send(:has_handler?, PaymentProcessor::HANDLER_SHOW_HTML)
+
+      @object.remove_handlers
+
+      assert_empty @object.instance_variable_get(:@handlers)
+    end
+
+    def test_call_handler
+      handler_called = false
+      handler = ->(*args){handler_called = true}
+
+      @object.set_handler PaymentProcessor::HANDLER_SAVE_CHANGES, &handler
+      @object.send :call_handler, PaymentProcessor::HANDLER_SAVE_CHANGES, PaymentTransaction.new, Response.new
+
+      assert_true handler_called
+    end
+
+    protected
+
+    # @return   [PaymentTransaction]
+    def payment_transaction
+      PaymentTransaction.new(
+      {
+        'payment'             =>  Payment.new(
+        {
+          'client_id'             => '_',
+          'paynet_id'             => '_',
+          'description'           => 'This is test payment',
+          'amount'                =>  99.1,
+          'currency'              => 'USD',
+          'customer'              =>  Customer.new(
+          {
+            'first_name'            => 'Vasya',
+            'last_name'             => 'Pupkin',
+            'email'                 => 'vass.pupkin@example.com',
+            'ip_address'            => '127.0.0.1',
+            'birthday'              => '112681'
+          }),
+          'billing_address'       =>  BillingAddress.new(
+          {
+            'country'               => 'US',
+            'state'                 => 'TX',
+            'city'                  => 'Houston',
+            'first_line'            => '2704 Colonial Drive',
+            'zip_code'              => '1235',
+            'phone'                 => '660-485-6353',
+            'cell_phone'            => '660-485-6353'
+          })
+        }),
+        'query_config'      => QueryConfig.new(
+        {
+          'login'               => '_',
+          'redirect_url'        => 'http://example.com',
+          'gateway_url_sandbox' => 'http://example.com/sandbox',
+          'signing_key'         => 'key'
+        })
+      });
+    end
+  end
+end

data/test/paynet_easy/paynet_easy_api/query/capture_query_test.rb

@@ -0,0 +1,48 @@
+require_relative './prototype/payment_query_test_prototype'
+require 'query/capture_query'
+require 'payment_data/payment'
+
+module PaynetEasy::PaynetEasyApi::Query
+  class CaptureQueryTest < Test::Unit::TestCase
+    include Prototype::PaymentQueryTestPrototype
+
+    def test_create_request
+      [
+        create_control_code(
+          LOGIN,
+          CLIENT_ID,
+          PAYNET_ID,
+          9910,
+          'EUR',
+          SIGNING_KEY
+        )
+      ].each do |control_code|
+        assert_create_request control_code
+      end
+    end
+
+    protected
+
+    def payment
+      Payment.new(
+      {
+        'client_id'             =>  CLIENT_ID,
+        'paynet_id'             =>  PAYNET_ID,
+        'amount'                =>  99.1,
+        'currency'              => 'EUR'
+      })
+    end
+
+    def query
+      CaptureQuery.new api_method
+    end
+
+    def payment_status
+      Payment::STATUS_CAPTURE
+    end
+
+    def api_method
+      'capture'
+    end
+  end
+end

data/test/paynet_easy/paynet_easy_api/query/create_card_ref_query_test.rb

@@ -0,0 +1,116 @@
+require_relative './prototype/sync_query_test_prototype'
+require 'query/create_card_ref_query'
+
+module PaynetEasy::PaynetEasyApi::Query
+  class CreateCardRefQueryTest < Test::Unit::TestCase
+    include Prototype::SyncQueryTestPrototype
+
+    def test_create_request
+      [
+        create_control_code(
+          LOGIN,
+          CLIENT_ID,
+          PAYNET_ID,
+          SIGNING_KEY
+        )
+      ].each do |control_code|
+        assert_create_request control_code
+      end
+    end
+
+    def test_create_request_with_empty_fields
+      payment_transaction = PaymentTransaction.new(
+      {
+        'payment'       => Payment.new(
+        {
+          'status'        => Payment::STATUS_CAPTURE
+        }),
+        'query_config'  => QueryConfig.new(
+        {
+          'signing_key'   => SIGNING_KEY
+        }),
+        'status'        => PaymentTransaction::STATUS_APPROVED
+      })
+
+      assert_raise ValidationError, 'Some required fields missed or empty in Payment' do
+        query.create_request payment_transaction
+      end
+    end
+
+    alias :sync_query_test_payment_transaction :payment_transaction
+
+    def test_create_request_with_not_ended_payment
+      assert_raise ValidationError, 'Only finished payment transaction can be used for create-card-ref-id' do
+        query.create_request sync_query_test_payment_transaction
+      end
+    end
+
+    def test_create_request_with_new_payment
+      payment = Payment.new(
+      {
+        'client_id' => CLIENT_ID,
+        'paynet_id' => PAYNET_ID
+      })
+
+      payment_transaction = payment_transaction()
+      payment_transaction.payment = payment
+
+      assert_raise ValidationError, 'Can not use new payment for create-card-ref-id' do
+        query.create_request payment_transaction
+      end
+    end
+
+    def test_process_success_response_with_empty_fields
+      response = Response.new(
+      {
+        'type'              =>  success_type,
+        'status'            => 'processing',
+        'paynet-order-id'   =>  PAYNET_ID,
+        'merchant-order-id' =>  CLIENT_ID,
+        'serial-number'     => '_'
+      })
+
+      assert_raise ValidationError, 'Some required fields missed or empty in Response: card-ref-id' do
+        query.process_response payment_transaction, response
+      end
+    end
+
+    def test_process_response_approved
+      [
+        {
+          'type'              =>  success_type,
+          'status'            => 'approved',
+          'card-ref-id'       =>  RECURRENT_CARD_FROM_ID,
+          'serial-number'     => '_'
+        }
+      ].each do |response|
+        assert_process_response_approved response
+      end
+    end
+
+    protected
+
+    def payment_transaction
+      payment_transaction = sync_query_test_payment_transaction
+      payment_transaction.status = PaymentTransaction::STATUS_APPROVED
+      payment_transaction
+    end
+
+    def payment
+      Payment.new(
+      {
+        'client_id'             => CLIENT_ID,
+        'paynet_id'             => PAYNET_ID,
+        'status'                => Payment::STATUS_PREAUTH
+      })
+    end
+
+    def success_type
+      'create-card-ref-response'
+    end
+
+    def query
+      CreateCardRefQuery.new '_'
+    end
+  end
+end