vantiv 0.3.0 → 1.0.0

data/lib/vantiv/api/transaction_response_representer_xml.rb

@@ -0,0 +1,54 @@
+require 'vantiv/api/account_updater_response'
+require 'vantiv/api/apple_pay_response'
+
+class TransactionResponseRepresenterXml < Representable::Decorator
+  include Representable::XML
+
+  property :id, as: :id, property: true
+  property :report_group, as: :reportGroup, property: true
+  property :customer_id, as: :customerId, property: true
+
+  property :transaction_id, as: :litleTxnId
+  property :payment_account_id, as: :litleToken
+  property :order_id, as: :orderId
+  property :response_code, as: :response
+  property :response_time, as: :responseTime
+  property :message
+  property :auth_code, as: :authCode
+  property :type, as: :type
+
+  property :account_updater, as: :accountUpdater, class: Vantiv::Api::AccountUpdaterResponse do
+    property :original_card_token_info, as: :originalCardTokenInfo, class: Vantiv::Api::CardTokenInfo do
+      property :payment_account_id, as: :litleToken
+      property :card_type, as: :type
+      property :bin
+      property :expiry_date, as: :expDate
+    end
+
+    property :new_card_token_info, as: :newCardTokenInfo, class: Vantiv::Api::CardTokenInfo do
+      property :payment_account_id, as: :litleToken
+      property :card_type, as: :type
+      property :bin
+      property :expiry_date, as: :expDate
+    end
+
+    property :extended_card_response, as: :extendedCardResponse, class: Vantiv::Api::ExtendedCardResponse do
+      property :code
+      property :message
+    end
+  end
+
+  property :fraud_result, as: :fraudResult, class: Vantiv::Api::FraudResult do
+    property :avs_result, as: :avsResult
+  end
+
+  property :token_response, as: :tokenResponse, class: Vantiv::Api::CardTokenInfo  do
+    property :payment_account_id, as: :litleToken
+    property :card_type, as: :type
+    property :bin
+  end
+
+  property :apple_pay_response, as: :applepayResponse, class: Vantiv::Api::ApplePayResponse do
+    property :online_payment_cryptogram, as: :onlinePaymentCryptogram
+  end
+end

data/lib/vantiv/certification/paypage_server.rb

@@ -13,7 +13,13 @@ module Vantiv
 
       def start
         if threaded
-          @server_thread = Thread.new { start_server }
+          @server_thread = Thread.new do
+            compile_template
+            server = WEBrick::HTTPServer.new :Port => port, :DocumentRoot => document_root
+            Thread.current.thread_variable_set(:server, server)
+            trap('INT') { server.shutdown }
+            server.start
+          end
         else
           start_server
         end
@@ -24,7 +30,12 @@ module Vantiv
       end
 
       def stop
-        threaded ? Thread.kill(server_thread) : stop_server
+        if threaded
+          server_thread.thread_variable_get(:server).shutdown
+          Thread.kill(server_thread)
+        else
+          stop_server
+        end
       end
 
       private

data/lib/vantiv/certification/response_cache.rb

@@ -6,22 +6,14 @@ module Vantiv
       end
 
       def push(cert_name, response)
-        responses[cert_name] = response
+        @responses[cert_name] = response
       end
 
       def access_value(values_tree)
         cert_name = values_tree.shift
-        response_body = responses[cert_name].body
-
-        get_value(response_body, values_tree)
-      end
-
-      private
-
-      attr_reader :responses
-
-      def get_value(source, keys)
-        keys.any? ? get_value(source[keys.shift], keys) : source
+        response = @responses[cert_name]
+        method_chain = values_tree.join('.')
+        response.instance_eval(method_chain)
       end
     end
 

data/lib/vantiv/certification/validation_test_runner.rb

@@ -6,20 +6,30 @@ require 'vantiv/certification/cert_request_body_compiler'
 module Vantiv
   module Certification
     class ValidationTestRunner
-
-      def self.run(filter_by: '', save_to:)
-        new(filter_by: filter_by, save_to: save_to).run
+      ENDPOINT_RESPONSE_OBJECT = {
+        Api::Endpoints::TOKENIZATION => Api::TokenizationResponse.new,
+        Api::Endpoints::AUTHORIZATION => Api::LiveTransactionResponse.new(:auth),
+        Api::Endpoints::AUTH_REVERSAL => Api::TiedTransactionResponse.new(:auth_reversal),
+        Api::Endpoints::CAPTURE => Api::TiedTransactionResponse.new(:capture),
+        Api::Endpoints::SALE => Api::LiveTransactionResponse.new(:sale),
+        Api::Endpoints::CREDIT => Api::TiedTransactionResponse.new(:credit),
+        Api::Endpoints::RETURN => Api::TiedTransactionResponse.new(:return),
+        Api::Endpoints::VOID => Api::TiedTransactionResponse.new(:void)
+      }
+
+      def self.run(save_to:, filter_by: '')
+        new(save_to: save_to, filter_by: filter_by).run
       end
 
-      def initialize(filter_by: '', save_to:)
-        @filter_by = filter_by
+      def initialize(save_to:, filter_by: '')
         @certs_file = save_to
+        @filter_by = filter_by
       end
 
       def run
         fixtures.each do |file_name|
           cert_name = get_cert_name(file_name)
-          next if filter_by && !/L_#{filter_by}_\d*/.match(cert_name)
+          next if filter_by && !/#{filter_by}_\d*/.match(cert_name)
 
           contents = JSON.parse(File.read(file_name))
           run_request(
@@ -37,7 +47,8 @@ module Vantiv
 
       def create_body(base_body)
         compiled_base = request_body_compiler.compile(base_body)
-        Vantiv::Api::RequestBodyGenerator.run(compiled_base)
+        request_body = Vantiv::Api::RequestBody.new
+        RequestBodyRepresenter.new(request_body).from_json(compiled_base.to_json)
       end
 
       def fixtures
@@ -92,16 +103,24 @@ module Vantiv
         response = Vantiv::Api::Request.new(
           endpoint: endpoint,
           body: body,
-          response_object: Vantiv::Api::Response.new
+          response_object: ENDPOINT_RESPONSE_OBJECT.fetch(endpoint)
         ).run
 
         if response.api_level_failure?
-          error_message = "CERT FAILED: #{cert_name} \n WITH: #{response.body}"
+          error_message = "CERT FAILED: #{cert_name} \n WITH: #{response.raw_body}"
           raise StandardError.new(error_message)
         end
 
+        transaction_id = get_transaction_id(response)
+
         response_cache.push(cert_name, response)
-        results_file << "#{cert_name},#{response.request_id}\n"
+        results_file << "#{cert_name},#{transaction_id}\n"
+      end
+
+      def get_transaction_id(response)
+        transaction_response_name = response.send(:transaction_response_name)
+        transaction_response = response.body.send(transaction_response_name)
+        transaction_response.transaction_id
       end
     end
   end

data/lib/vantiv/mocked_sandbox.rb

@@ -10,8 +10,9 @@ module Vantiv
       end
       Vantiv::Api::Request.send(:define_method, :run_request) do
         Vantiv::MockedSandbox::ApiRequest.run(
-          endpoint: endpoint,
-          body: body
+          endpoint: @endpoint,
+          body: body,
+          response_object: @response_object
         )
       end
     end

data/lib/vantiv/mocked_sandbox/api_request.rb

@@ -1,22 +1,30 @@
+require 'pathname'
+require 'vantiv/api/response'
+require 'vantiv/api/live_transaction_response'
+require 'vantiv/mocked_sandbox/mocked_response_representer'
+
 module Vantiv
   module MockedSandbox
     class ApiRequest
       class EndpointNotMocked < StandardError; end
       class FixtureNotFound < StandardError; end
 
-      def self.run(endpoint:, body:)
-        new(endpoint, body).run
+      def self.run(endpoint:, body:, response_object:)
+        new(endpoint, body, response_object).run
       end
 
-      def initialize(endpoint, request_body)
+      def initialize(endpoint, request_body, response_object)
         self.endpoint = endpoint
-        self.request_body = JSON.parse(request_body)
+        self.request_body = request_body
+        self.response_object = response_object
       end
 
       def run
         if endpoint == Api::Endpoints::TOKENIZATION
           if direct_post?
             load_fixture("tokenize_by_direct_post", card_number)
+          else
+            load_fixture("tokenize", temporary_token)
           end
         elsif endpoint == Api::Endpoints::SALE
           load_fixture("auth_capture", card_number_from_payment_account_id)
@@ -35,46 +43,67 @@ module Vantiv
         else
           raise EndpointNotMocked.new("#{endpoint} is not mocked!")
         end
-        {
-          httpok: fixture["httpok"],
-          http_response_code: fixture["http_response_code"],
-          body: JSON.parse(ERB.new(fixture["response_body"]).result(binding))
-        }
       end
 
       private
 
-      attr_accessor :endpoint, :request_body, :fixture
+      attr_accessor :endpoint, :request_body, :fixture, :response_object
 
       def direct_post?
-        request_body["Card"] && request_body["Card"]["AccountNumber"] != nil
+        !card_number.nil?
+      end
+
+      def temporary_token
+        request_body.card.paypage_registration_id
       end
 
       def card_number
-        request_body["Card"]["AccountNumber"]
+        request_body.card.account_number
       end
 
       def card_number_from_payment_account_id
         TestCard.find_by_payment_account_id(
-          request_body["PaymentAccount"]["PaymentAccountID"]
+          request_body.payment_account.id
         ).card_number
       end
 
-      def load_fixture(api_method, card_number = nil)
-        fixture_file_name = card_number ? "#{api_method}--#{card_number}" : api_method
-        begin
-          self.fixture = File.open("#{MockedSandbox.fixtures_directory}#{fixture_file_name}.json.erb", 'r') do |f|
-            raw_fixture = JSON.parse(f.read)
-            # Prevent rails overridden version of to_json from encoding erb sepcial characters
-            raw_fixture["response_body"] = JSON::Ext::Generator::GeneratorMethods::Hash
-              .instance_method(:to_json)
-              .bind(raw_fixture["response_body"])
-              .call
-            raw_fixture
-          end
-        rescue Errno::ENOENT
-          raise FixtureNotFound.new("Fixture not found for api method: #{api_method}, card number: #{card_number}")
+      def load_fixture(api_method, card_number_or_temporary_token = nil)
+        fixture_file_name = card_number_or_temporary_token ? "#{api_method}--#{card_number_or_temporary_token}" : api_method
+
+        fixtures_path = Pathname.new Vantiv::MockedSandbox.fixtures_directory
+
+        path = fixtures_path.children.detect do |child_path|
+          filename = child_path.basename.to_s.split(child_path.extname).first
+          fixture_file_name.start_with? filename
+        end
+
+        if path.nil?
+          raise FixtureNotFound.new("Fixture not found for api method: #{api_method}, card number or temporary token: #{card_number_or_temporary_token}")
+        end
+
+        self.fixture = path.open do |f|
+          raw_fixture = f.read
+          response = MockedResponseRepresenter.new(response_object).from_json(raw_fixture)
+
+          populated_response = populate_dynamic_response(response)
+
+          populated_response.raw_body = response.body.to_s
+          populated_response
+        end
+      end
+
+      def populate_dynamic_response(response)
+        dynamic_response = response.dup
+        transaction_response = dynamic_response.send(:litle_transaction_response)
+
+        transaction_response.report_group = Vantiv.default_report_group
+        transaction_response.response_time = Time.now.strftime('%FT%T')
+        transaction_response.transaction_id = rand(10**17).to_s
+
+        if transaction_response.post_date
+          transaction_response.post_date = Time.now.strftime('%F')
         end
+        dynamic_response
       end
     end
   end

data/lib/vantiv/mocked_sandbox/fixture_generator.rb

@@ -1,9 +1,9 @@
-require 'vantiv/mocked_sandbox/dynamic_response_body'
+require 'vantiv/certification/paypage_driver'
+require 'vantiv/mocked_sandbox/mocked_response_representer'
 
 module Vantiv
   module MockedSandbox
     class FixtureGenerator
-
       def self.generate_all
         new.run
       end
@@ -11,6 +11,8 @@ module Vantiv
       attr_accessor :card
 
       def run
+        record_tokenize
+
         TestCard.all.each do |card|
           self.card = CardforFixtureGeneration.new(card)
 
@@ -30,6 +32,44 @@ module Vantiv
 
       private
 
+      def record_tokenize
+        @paypage_driver = Vantiv::Certification::PaypageDriver.new
+        @paypage_driver.start
+
+        TestTemporaryToken.all.each do |test_temporary_token|
+          if requires_live_paypage_response?(test_temporary_token)
+            test_card = Vantiv::TestCard.valid_account
+            mocked_payment_account_id = test_card.mocked_sandbox_payment_account_id
+            live_temporary_token = @paypage_driver.get_paypage_registration_id(test_card.card_number, test_card.cvv)
+          else
+            mocked_payment_account_id = nil
+            live_temporary_token = test_temporary_token
+          end
+
+          record_tokenize_for_test_token(
+            test_temporary_token: test_temporary_token,
+            live_temporary_token: live_temporary_token,
+            mocked_payment_account_id: mocked_payment_account_id
+          )
+        end
+
+        @paypage_driver.stop
+      end
+
+      def record_tokenize_for_test_token(test_temporary_token:, live_temporary_token:, mocked_payment_account_id:)
+        cert_response = Vantiv.tokenize(temporary_token: live_temporary_token)
+        cert_response.body.register_token_response.payment_account_id = mocked_payment_account_id
+        file_name = "tokenize--#{test_temporary_token}"[0..94]
+        write_fixture_to_file(
+          file_name,
+          cert_response
+        )
+      end
+
+      def requires_live_paypage_response?(test_temporary_token)
+        test_temporary_token == TestTemporaryToken.valid_temporary_token
+      end
+
       def record_tokenize_by_direct_post
         cert_response = Vantiv.tokenize_by_direct_post(
           card_number: card.card_number,
@@ -37,12 +77,8 @@ module Vantiv
           expiry_year: card.expiry_year,
           cvv: card.cvv
         )
-        dynamic_body = DynamicResponseBody.generate(
-          body: cert_response.body,
-          litle_txn_name: "registerTokenResponse",
-          mocked_payment_account_id: card.mocked_sandbox_payment_account_id
-        )
-        write_fixture_to_file("tokenize_by_direct_post--#{card.card_number}", cert_response, dynamic_body)
+        cert_response.body.register_token_response.payment_account_id = card.mocked_sandbox_payment_account_id
+        write_fixture_to_file("tokenize_by_direct_post--#{card.card_number}", cert_response)
       end
 
       def record_auth_capture
@@ -54,11 +90,7 @@ module Vantiv
           customer_id: "not-dynamic-cust-id",
           order_id: "not-dynamic-order-id"
         )
-        dynamic_body = DynamicResponseBody.generate(
-          body: cert_response.body,
-          litle_txn_name: "saleResponse"
-        )
-        write_fixture_to_file("auth_capture--#{card.card_number}", cert_response, dynamic_body)
+        write_fixture_to_file("auth_capture--#{card.card_number}", cert_response)
       end
 
       def record_auth
@@ -70,11 +102,7 @@ module Vantiv
           customer_id: "not-dynamic-cust-id",
           order_id: "not-dynamic-order-id"
         )
-        dynamic_body = DynamicResponseBody.generate(
-          body: cert_response.body,
-          litle_txn_name: "authorizationResponse"
-        )
-        write_fixture_to_file("auth--#{card.card_number}", cert_response, dynamic_body)
+        write_fixture_to_file("auth--#{card.card_number}", cert_response)
       end
 
       def record_refund
@@ -86,33 +114,21 @@ module Vantiv
           customer_id: "not-dynamic-cust-id",
           order_id: "not-dynamic-order-id"
         )
-        dynamic_body = DynamicResponseBody.generate(
-          body: cert_response.body,
-          litle_txn_name: "creditResponse"
-        )
-        write_fixture_to_file("refund--#{card.card_number}", cert_response, dynamic_body)
+        write_fixture_to_file("refund--#{card.card_number}", cert_response)
       end
 
       def record_capture
         cert_response = Vantiv.capture(
           transaction_id: rand(10**17).to_s
         )
-        dynamic_body = DynamicResponseBody.generate(
-          body: cert_response.body,
-          litle_txn_name: "captureResponse"
-        )
-        write_fixture_to_file("capture", cert_response, dynamic_body)
+        write_fixture_to_file("capture", cert_response)
       end
 
       def record_auth_reversal
         cert_response = Vantiv.auth_reversal(
           transaction_id: rand(10**17).to_s
         )
-        dynamic_body = DynamicResponseBody.generate(
-          body: cert_response.body,
-          litle_txn_name: "authReversalResponse"
-        )
-        write_fixture_to_file("auth_reversal", cert_response, dynamic_body)
+        write_fixture_to_file("auth_reversal", cert_response)
       end
 
       def record_credit
@@ -120,31 +136,21 @@ module Vantiv
           transaction_id: rand(10**17).to_s,
           amount: 1010
         )
-        dynamic_body = DynamicResponseBody.generate(
-          body: cert_response.body,
-          litle_txn_name: "creditResponse"
-        )
-        write_fixture_to_file("credit", cert_response, dynamic_body)
+        write_fixture_to_file("credit", cert_response)
       end
 
       def record_void
         cert_response = Vantiv.void(
           transaction_id: rand(10**17).to_s
         )
-        dynamic_body = DynamicResponseBody.generate(
-          body: cert_response.body,
-          litle_txn_name: "voidResponse"
-        )
-        write_fixture_to_file("void", cert_response, dynamic_body)
+        write_fixture_to_file("void", cert_response)
       end
 
-      def write_fixture_to_file(file_name, response, dynamic_body)
-        File.open("#{MockedSandbox.fixtures_directory}/#{file_name}.json.erb", 'w') do |fixture|
-          fixture << JSON.pretty_generate({
-            httpok: response.httpok,
-            http_response_code: response.http_response_code,
-            response_body: dynamic_body
-          })
+      def write_fixture_to_file(file_name, response)
+        File.open("#{MockedSandbox.fixtures_directory}/#{file_name}.json", 'w') do |fixture|
+          fixture << JSON.pretty_generate(
+            MockedResponseRepresenter.new(response).to_hash
+          )
         end
       end
     end