payneteasy-payneteasyapi 0.1.0

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

@@ -0,0 +1,116 @@
+require_relative './prototype/sync_query_test_prototype'
+require 'query/get_card_info_query'
+require 'payment_data/recurrent_card'
+
+module PaynetEasy::PaynetEasyApi::Query
+  class GetCardInfoQueryTest < Test::Unit::TestCase
+    include Prototype::SyncQueryTestPrototype
+
+    def test_create_request
+      [
+        create_control_code(
+          LOGIN,
+          RECURRENT_CARD_FROM_ID,
+          SIGNING_KEY
+        )
+      ].each do |control_code|
+        assert_create_request control_code
+      end
+    end
+
+    def test_process_response_approved
+      [
+        {
+          'type'              =>  success_type,
+          'paynet-order-id'   =>  PAYNET_ID,
+          'merchant-order-id' =>  CLIENT_ID,
+          'serial-number'     => '_',
+          'card-printed-name' => 'Vasya Pupkin',
+          'expire-month'      => '12',
+          'expire-year'       => '14',
+          'bin'               => '4485',
+          'last-four-digits'  => '9130'
+        }
+      ].each do |response|
+        assert_process_response_approved response
+      end
+    end
+
+    def assert_process_response_approved(response)
+      payment_transaction = payment_transaction()
+      recurrent_card      = payment_transaction.payment.recurrent_card_from
+      response_object     = Response.new response
+
+      query.process_response payment_transaction, response_object
+
+      assert_equal response_object['card-printed-name'],  recurrent_card.card_printed_name
+      assert_equal response_object['expire-year'],        recurrent_card.expire_year
+      assert_equal response_object['expire-month'],       recurrent_card.expire_month
+      assert_equal response_object['bin'],                recurrent_card.bin
+      assert_equal response_object['last-four-digits'],   recurrent_card.last_four_digits
+
+      [payment_transaction, response]
+    end
+
+    def test_process_error_response_with_invalid_id
+      response = Response.new(
+      {
+        'type'              => 'error',
+        'client_orderid'    => 'invalid',
+        'card-printed-name' => 'Vasya Pupkin',
+        'expire-month'      => '12',
+        'expire-year'       => '14',
+        'bin'               => '4485',
+        'last-four-digits'  => '9130'
+      })
+
+      assert_raise ValidationError, "Response client_id 'invalid' does not match Payment client_id" do
+        query.process_response payment_transaction, response
+      end
+    end
+
+    def test_process_success_response_with_invalid_id
+      response = Response.new(
+      {
+        'type'              => success_type,
+        'paynet-order-id'   => '_',
+        'merchant-order-id' => '_',
+        'serial-number'     => '_',
+        'card-ref-id'       => '_',
+        'redirect-url'      => '_',
+        'client_orderid'    => 'invalid',
+        'card-printed-name' => 'Vasya Pupkin',
+        'expire-month'      => '12',
+        'expire-year'       => '14',
+        'bin'               => '4485',
+        'last-four-digits'  => '9130'
+      })
+
+      assert_raise ValidationError, "Response client_id '_' does not match Payment client_id" do
+        query.process_response payment_transaction, response
+      end
+    end
+
+    protected
+
+    def payment
+      Payment.new(
+      {
+        'client_id'             => CLIENT_ID,
+        'paynet_id'             => PAYNET_ID,
+        'recurrent_card_from'   => RecurrentCard.new(
+        {
+          'paynet_id'             => RECURRENT_CARD_FROM_ID
+        })
+      })
+    end
+
+    def success_type
+      'get-card-info-response'
+    end
+
+    def query
+      GetCardInfoQuery.new '_'
+    end
+  end
+end

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

@@ -0,0 +1,59 @@
+require_relative './prototype/payment_query_test_prototype'
+require 'query/make_rebill_query'
+require 'payment_data/customer'
+require 'payment_data/recurrent_card'
+
+module PaynetEasy::PaynetEasyApi::Query
+  class MakeRebillQueryTest < Test::Unit::TestCase
+    include Prototype::PaymentQueryTestPrototype
+
+    def test_create_request
+      [
+        create_control_code(
+          END_POINT,
+          CLIENT_ID,
+          '99',                   # amount
+          RECURRENT_CARD_FROM_ID,
+          SIGNING_KEY
+        )
+      ].each do |control_code|
+        assert_create_request control_code
+      end
+    end
+
+    protected
+
+    # @return   [Payment]
+    def payment
+      Payment.new(
+      {
+        'client_id'             =>  CLIENT_ID,
+        'paynet_id'             =>  PAYNET_ID,
+        'description'           => 'This is test payment',
+        'amount'                =>  0.99,
+        'currency'              => 'USD',
+        'customer'              =>  Customer.new(
+        {
+          'ip_address'            => '127.0.0.1',
+        }),
+        'recurrent_card_from'   =>  RecurrentCard.new(
+        {
+          'paynet_id'             => RECURRENT_CARD_FROM_ID,
+          'cvv2'                  => 123
+        })
+      })
+    end
+
+    def payment_status
+      Payment::STATUS_CAPTURE
+    end
+
+    def api_method
+      'make-rebill'
+    end
+
+    def query
+      MakeRebillQuery.new api_method
+    end
+  end
+end

data/test/paynet_easy/paynet_easy_api/query/prototype/payment_query_test_prototype.rb

@@ -0,0 +1,117 @@
+require_relative './query_test_prototype'
+
+module PaynetEasy::PaynetEasyApi::Query::Prototype
+  module PaymentQueryTestPrototype
+    include QueryTestPrototype
+
+    alias :query_test_assert_create_request :assert_create_request
+
+    def assert_create_request(control_code)
+      payment_transaction, request = query_test_assert_create_request control_code
+      payment = payment_transaction.payment
+
+      assert_true payment.has_processing_transaction?
+      assert_equal payment_status, payment.status
+      assert_equal PaymentTransaction::PROCESSOR_QUERY, payment_transaction.processor_type
+      assert_equal api_method, payment_transaction.processor_name
+
+      [payment_transaction, request]
+    end
+
+    def test_create_request_with_processing_payment
+      payment_transaction = payment_transaction()
+      payment_transaction.status = PaymentTransaction::STATUS_PROCESSING
+
+      assert_raise ValidationError, 'Payment can not has processing payment transaction' do
+        query.create_request payment_transaction
+      end
+    end
+
+    def test_create_request_with_finished_transaction
+      payment_transaction = payment_transaction()
+      payment_transaction.status = PaymentTransaction::STATUS_APPROVED
+
+      assert_raise ValidationError, 'Payment transaction must be new' do
+        query.create_request payment_transaction
+      end
+    end
+
+    def test_process_response_processing
+      [
+        {
+          'type'              =>  success_type,
+          'paynet-order-id'   =>  PAYNET_ID,
+          'merchant-order-id' =>  CLIENT_ID,
+          'serial-number'     => '_'
+        }
+      ].each do |response|
+        assert_process_response_processing response
+      end
+    end
+
+    def assert_process_response_processing(response)
+      payment_transaction = payment_transaction()
+      response_object = Response.new response
+
+      query.process_response payment_transaction, response_object
+
+      assert_equal PAYNET_ID, payment_transaction.payment.paynet_id
+      assert_true payment_transaction.processing?
+      assert_false payment_transaction.finished?
+      assert_false payment_transaction.has_errors?
+
+      [payment_transaction, response_object]
+    end
+
+    def test_process_response_error
+      [
+        {
+          'type'              => 'validation-error',
+          'serial-number'     => '_',
+          'error-message'     => 'validation-error message',
+          'error-code'        =>  1
+        },
+        {
+          'type'              => 'error',
+          'error-message'     => 'test type error message',
+          'error-code'        =>  5
+        }
+      ].each do |response|
+        assert_process_response_error response
+      end
+    end
+
+    def test_validate_client_id_with_different_types
+      payment_transaction = payment_transaction()
+      payment_transaction.payment.client_id = 123
+
+      response = Response.new(
+      {
+        'type'              =>  success_type,
+        'status'            => 'approved',
+        'paynet-order-id'   =>  PAYNET_ID,
+        'merchant-order-id' => '123',
+        'serial-number'     => '_',
+        'redirect-url'      => 'http://example.com'
+      })
+
+      query.process_response payment_transaction, response
+
+      assert_true payment_transaction.approved?
+    end
+
+    protected
+
+    def success_type
+      'async-response'
+    end
+
+    def api_method
+      raise NotImplementedError, 'You must return query api method from this method'
+    end
+
+    def payment_status
+      raise NotImplementedError, 'You must return query payment status from this method'
+    end
+  end
+end

data/test/paynet_easy/paynet_easy_api/query/prototype/query_test_prototype.rb

@@ -0,0 +1,190 @@
+require 'test/unit'
+require 'digest/sha1'
+require 'paynet_easy_api'
+require 'query/prototype/query'
+require 'payment_data/payment_transaction'
+require 'payment_data/payment'
+require 'payment_data/query_config'
+require 'transport/response'
+require 'error/validation_error'
+require 'error/paynet_error'
+
+module PaynetEasy::PaynetEasyApi::Query::Prototype
+  module QueryTestPrototype
+    include PaynetEasy::PaynetEasyApi::PaymentData
+    include PaynetEasy::PaynetEasyApi::Transport
+    include PaynetEasy::PaynetEasyApi::Error
+
+    LOGIN                     = 'test-login'
+    END_POINT                 =  789
+    SIGNING_KEY               = 'D5F82EC1-8575-4482-AD89-97X6X0X20X22'
+    CLIENT_ID                 = 'CLIENT-112233'
+    PAYNET_ID                 = 'PAYNET-112233'
+
+    RECURRENT_CARD_FROM_ID    = '5588943'
+    RECURRENT_CARD_TO_ID      = '5588978'
+
+    def test_create_request
+      raise NotImplementedError
+    end
+
+    def assert_create_request(control_code)
+      payment_transaction = payment_transaction()
+
+      request         = query.create_request payment_transaction
+      request_fields  = request.request_fields
+
+      assert_not_nil request.api_method
+      assert_not_nil request.end_point
+      assert_not_nil request_fields['control']
+      assert_equal control_code, request_fields['control']
+      assert_false payment_transaction.has_errors?
+
+      [payment_transaction, request]
+    end
+
+    def test_create_request_with_empty_fields
+      payment_transaction = PaymentTransaction.new(
+      {
+        'payment'       => Payment.new(
+        {
+          'status'        => Payment::STATUS_CAPTURE
+        }),
+        'query_config'  => query_config
+      })
+
+      query = query()
+
+      assert_raise ValidationError, 'Some required fields missed or empty in Payment' do
+        query.create_request payment_transaction
+      end
+    end
+
+    def test_create_request_with_invalid_fields
+      payment_transaction = payment_transaction()
+      payment_transaction.payment.client_id   = '123456789012345678901234567890'
+      payment_transaction.query_config.login  = '123456789012345678901234567890123456789012345678901234567890'
+
+      assert_raise ValidationError, 'Some fields invalid in Payment' do
+        query.create_request payment_transaction
+      end
+    end
+
+    def test_process_response_error
+      raise NotImplementedError
+    end
+
+    def assert_process_response_error(response)
+      payment_transaction = payment_transaction()
+      response_object     = Response.new response
+
+      begin
+        query.process_response payment_transaction, response_object
+      rescue PaynetError => error
+        assert_true payment_transaction.error?
+        assert_true payment_transaction.finished?
+        assert_true payment_transaction.has_errors?
+        assert_equal response_object.error_message, error.message
+
+        return [payment_transaction, response_object]
+      else
+        flunk 'Exception must be raised'
+      end
+    end
+
+    def test_process_success_response_with_invalid_type
+      response = Response.new 'type' => 'invalid'
+
+      assert_raise ValidationError, "Response type 'invalid' does not match success response type" do
+        query.process_response payment_transaction, response
+      end
+    end
+
+    def test_process_success_response_with_empty_fields
+      response = Response.new 'type' => success_type
+
+      assert_raise ValidationError, 'Some required fields missed or empty in Response' do
+        query.process_response payment_transaction, response
+      end
+    end
+
+    def test_process_response_with_invalid_id
+      response = Response.new(
+      {
+        'type'              => success_type,
+        'paynet-order-id'   => '_',
+        'merchant-order-id' => '_',
+        'serial-number'     => '_',
+        'card-ref-id'       => '_',
+        'redirect-url'      => '_',
+        'client_orderid'    => 'invalid'
+      })
+
+      assert_raise ValidationError, "Response client_id '_' does not match Payment client_id" do
+        query.process_response payment_transaction, response
+      end
+    end
+
+    def test_process_error_response_without_type
+      response = Response.new 'status' => 'error'
+
+      assert_raise ValidationError, 'Unknown response type' do
+        query.process_response payment_transaction, response
+      end
+    end
+
+    def test_process_error_response_with_invalid_id
+      response = Response.new 'type' => 'error', 'client_orderid' => 'invalid'
+
+      assert_raise ValidationError, "Response client_id 'invalid' does not match Payment client_id" do
+        query.process_response payment_transaction, response
+      end
+    end
+
+    protected
+
+    # @return   [String]
+    def success_type
+      raise NotImplementedError, 'You must return success type for query response form this method'
+    end
+
+    # @return   [Query]
+    def query
+      raise NotImplementedError, 'You must implement query creation in this method'
+    end
+
+    # @return   [PaymentTransaction]
+    def payment_transaction
+      payment_transaction = PaymentTransaction.new({}, true)
+
+      payment_transaction.payment       = payment()
+      payment_transaction.query_config  = query_config()
+
+      payment_transaction
+    end
+
+    # @return   [Payment]
+    def payment
+      raise NotImplementedError
+    end
+
+    # @return   [QueryConfig]
+    def query_config
+      QueryConfig.new(
+      {
+        'login'               =>  LOGIN,
+        'end_point'           =>  END_POINT,
+        'signing_key'         =>  SIGNING_KEY,
+        'site_url'            => 'http://example.com',
+        'gateway_url_sandbox' => 'https://example.com/sandbox_url',
+        'redirect_url'        => 'https://example.com/redirect_url',
+        'callback_url'        => 'https://example.com/callback_url'
+      })
+    end
+
+    # Create sha1 hash sum from all method arguments
+    def create_control_code(*args)
+      Digest::SHA1.hexdigest(args.join(''))
+    end
+  end
+end

data/test/paynet_easy/paynet_easy_api/query/prototype/sync_query_test_prototype.rb

@@ -0,0 +1,88 @@
+require_relative './query_test_prototype'
+
+module PaynetEasy::PaynetEasyApi::Query::Prototype
+  module SyncQueryTestPrototype
+    include QueryTestPrototype
+    
+    def test_process_response_approved
+      raise NotImplementedError
+    end
+
+    def assert_process_response_approved(response)
+      payment_transaction = payment_transaction()
+      response_object     = Response.new response
+
+      query.process_response payment_transaction, response_object
+
+      assert_true payment_transaction.approved?
+      assert_true payment_transaction.finished?
+      assert_false payment_transaction.has_errors?
+
+      [payment_transaction, response_object]
+    end
+
+    def test_process_response_declined
+      [
+        {
+          'type'              =>  success_type,
+          'status'            => 'filtered',
+          'paynet-order-id'   =>  PAYNET_ID,
+          'merchant-order-id' =>  CLIENT_ID,
+          'serial-number'     => '_',
+          'error-message'     => 'test filtered message',
+          'error-code'        =>  8876
+        },
+        {
+          'type'              =>  success_type,
+          'status'            => 'declined',
+          'paynet-order-id'   =>  PAYNET_ID,
+          'merchant-order-id' =>  CLIENT_ID,
+          'serial-number'     => '_',
+          'error-message'     => 'test error message',
+          'error-code'        =>  578
+        }
+      ].each do |response|
+        assert_process_response_declined response
+      end
+    end
+
+    def assert_process_response_declined(response)
+      payment_transaction = payment_transaction()
+      response_object     = Response.new response
+
+      query.process_response payment_transaction, response_object
+
+      assert_true payment_transaction.declined?
+      assert_true payment_transaction.finished?
+      assert_true payment_transaction.has_errors?
+
+      [payment_transaction, response_object]
+    end
+
+    def test_process_response_error
+      [
+        {
+          'type'              =>  success_type,
+          'status'            => 'error',
+          'paynet-order-id'   =>  PAYNET_ID,
+          'merchant-order-id' =>  CLIENT_ID,
+          'serial-number'     => '_',
+          'error-message'     => 'status error message',
+          'error-code'        =>  24
+        },
+        {
+          'type'              => 'validation-error',
+          'error-message'     => 'validation error message',
+          'error-code'        =>  1
+        },
+        {
+          'type'              => 'error',
+          'error-message'     => 'immediate error message',
+          'error-code'        =>  1
+        }
+      ].each do |response|
+        assert_process_response_error response
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+require 'test/unit'
+require 'paynet_easy_api'
+require 'query/query_factory'
+require 'query/create_card_ref_query'
+require 'query/return_query'
+
+module PaynetEasy::PaynetEasyApi::Query
+  class QueryFactoryTest < Test::Unit::TestCase
+    def setup
+      @object = QueryFactory.new
+    end
+
+    def test_query
+      query = @object.query 'create-card-ref'
+      assert_instance_of CreateCardRefQuery, query
+
+      query = @object.query 'return'
+      assert_instance_of ReturnQuery, query
+    end
+  end
+end

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

@@ -0,0 +1,58 @@
+require_relative './prototype/payment_query_test_prototype'
+require 'query/return_query'
+
+module PaynetEasy::PaynetEasyApi::Query
+  class ReturnQueryTest < 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
+
+    def test_create_request_with_finished_transaction
+      payment_transaction = payment_transaction()
+      payment_transaction.payment.status = Payment::STATUS_RETURN
+
+      assert_raise ValidationError, 'Payment must be paid up to return funds' do
+        query.create_request payment_transaction
+      end
+    end
+
+    protected
+
+    def payment
+      Payment.new(
+      {
+        'client_id'             =>  CLIENT_ID,
+        'paynet_id'             =>  PAYNET_ID,
+        'amount'                =>  99.1,
+        'currency'              => 'EUR',
+        'comment'               => 'cancel payment',
+        'status'                =>  Payment::STATUS_CAPTURE
+      })
+    end
+
+    def payment_status
+      Payment::STATUS_RETURN
+    end
+
+    def api_method
+      'return'
+    end
+
+    def query
+      ReturnQuery.new api_method
+    end
+  end
+end