vantiv 0.1.0

data/lib/vantiv/certification/paypage_server.rb

@@ -0,0 +1,70 @@
+require 'erb'
+require 'webrick'
+require 'vantiv'
+
+module Vantiv
+  module Certification
+    class PaypageServer
+      def initialize(threaded: true)
+        @threaded = threaded
+        @template = "#{Vantiv.root}/lib/vantiv/certification/views/index.html.erb"
+        @static_file_dir = "#{Vantiv.root}/tmp/e-protect"
+      end
+
+      def start
+        if threaded
+          @server_thread = Thread.new { start_server }
+        else
+          start_server
+        end
+      end
+
+      def root_path
+        "http://localhost:#{port}"
+      end
+
+      def stop
+        threaded ? Thread.kill(server_thread) : stop_server
+      end
+
+      private
+
+      attr_accessor :server, :server_thread, :threaded
+
+      def document_root
+        File.expand_path "#{static_file_dir}"
+      end
+
+      def port
+        8000
+      end
+
+      def start_server
+        compile_template
+        server = WEBrick::HTTPServer.new :Port => port, :DocumentRoot => document_root
+        trap('INT') { server.shutdown }
+        server.start
+      end
+
+      def stop_server
+        server.shutdown
+      end
+
+      def static_file_dir
+        unless File.directory?(@static_file_dir)
+          FileUtils.mkdir_p(@static_file_dir)
+        end
+        @static_file_dir
+      end
+
+      def compile_template
+        template = File.open(@template)
+        File.open("#{static_file_dir}/index.html", "w") do |f|
+          renderer = ERB.new(template.read)
+          f << renderer.result()
+        end
+      end
+    end
+  end
+end
+

data/lib/vantiv/certification/response_cache.rb

@@ -0,0 +1,29 @@
+module Vantiv
+  module Certification
+    class ResponseCache
+      def initialize
+        @responses = {}
+      end
+
+      def push(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
+      end
+    end
+
+  end
+end

data/lib/vantiv/certification/validation_test_runner.rb

@@ -0,0 +1,103 @@
+require 'vantiv'
+require 'vantiv/certification/paypage_driver'
+require 'vantiv/certification/response_cache'
+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
+      end
+
+      def initialize(filter_by: '', save_to:)
+        @filter_by = filter_by
+        @certs_file = save_to
+      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)
+
+          contents = JSON.parse(File.read(file_name))
+          run_request(
+            cert_name: cert_name,
+            endpoint: Vantiv::Api::Endpoints.const_get(contents["endpoint"]),
+            body: create_body(contents["body"])
+          )
+        end
+        shutdown
+      end
+
+      private
+
+      attr_reader :filter_by, :certs_file
+
+      def create_body(base_body)
+        compiled_base = request_body_compiler.compile(base_body)
+        Vantiv::Api::RequestBodyGenerator.run(compiled_base)
+      end
+
+      def fixtures
+        @fixtures ||= Dir.glob("#{Vantiv.root}/cert_fixtures/**/*")
+      end
+
+      def get_cert_name(file_name)
+        /.*\/cert_fixtures\/(\w*).json/.match(file_name)[1]
+      end
+
+      def paypage_driver
+        @paypage_driver ||= Vantiv::Certification::PaypageDriver.new.start
+      end
+
+      def response_cache
+        @response_cache ||= Vantiv::Certification::ResponseCache.new
+      end
+
+      def results_file
+        @results_file ||= File.open(certs_file, "w")
+      end
+
+      def request_body_compiler
+        @request_body_compiler ||= CertRequestBodyCompiler.new(
+          {
+            regex: /.*\$\{eProtect\.(.*)\}.*/,
+            fetcher: lambda do |value, match|
+              value.gsub(
+                /.*\$\{eProtect\.#{match}\}.*/,
+                paypage_driver.get_paypage_registration_id(match)
+              )
+            end
+          },
+          {
+            regex: /.*\#\{(.*)\}.*/,
+            fetcher: lambda do |value, match|
+              value.gsub(
+                /\#\{#{match}\}/,
+                  response_cache.access_value(match.split("."))
+              )
+            end
+          }
+        )
+      end
+
+      def shutdown
+        paypage_driver.stop
+        results_file.close
+      end
+
+      def run_request(cert_name:, endpoint:, body:)
+        response = Vantiv::Api::Request.new(
+          endpoint: endpoint,
+          body: body,
+          response_object: Vantiv::Api::Response.new
+        ).run
+
+        response_cache.push(cert_name, response)
+        results_file << "#{cert_name},#{response.request_id}\n"
+      end
+    end
+  end
+end

data/lib/vantiv/certification/views/index.html.erb

@@ -0,0 +1,76 @@
+<html>
+  <head>
+    <script src="http://ajax.googleapis.com/ajax/libs/jquery/1.10.2/jquery.min.js" type="text/javascript"></script>
+    <script src="https://request-prelive.np-securepaypage-litle.com/LitlePayPage/js/payframe-client.min.js" type="text/javascript"></script>
+    <script>
+      document.addEventListener('DOMContentLoaded', function(){
+        var payframeClientCallback = function(response) {
+          if (response.response !== '870') {
+            document.getElementById('request-status').innerHTML = 'Request Failed';
+            document.getElementById('payment-errors').innerHTML = response.message;
+          } else {
+            document.getElementById('temp-token').innerHTML = response.paypageRegistrationId;
+            document.getElementById('request-status').innerHTML = 'Request Complete';
+          }
+        }
+
+        var client = new LitlePayframeClient({
+          "paypageId": "<%= Vantiv.paypage_id %>",
+          "style":"sample2",
+          "height":"250",
+          "reportGroup":"IFrame Sample",
+          "timeout":"60000",
+          "div": "payframe",
+          "callback": payframeClientCallback,
+          "showCvv": true,
+          "months": {
+            "1":"January",
+            "2":"February",
+            "3":"March",
+            "4":"April",
+            "5":"May",
+            "6":"June",
+            "7":"July",
+            "8":"August",
+            "9":"September",
+            "10":"October",
+            "11":"November",
+            "12":"December"
+          },
+          "numYears": 8,
+          "tooltipText": "A CVV is the 3 digit code on the back of your Visa, MasterCard and Discover or a 4 digit code on the front of your American Express",
+          "tabIndex": {
+            "cvv":4,
+            "accountNumber":1,
+            "expMonth":2,
+            "expYear":3
+          },
+          "placeholderText": {
+            "cvv":"CVV",
+            "accountNumber":"Account Number"
+          }
+        });
+
+        window.onFormSubmit = function(){
+          client.getPaypageRegistrationId({
+            "id": "12345",
+            "orderId": "somethingunintelligble"
+          });
+
+          return false;
+        }
+      });
+    </script>
+  </head>
+  <body>
+    <h1>Vantiv Test Paypage</h1>
+    <form id="payment-form" onsubmit="return onFormSubmit()">
+      <div id="payframe"></div>
+      <div id="payment-errors"></div>
+      <div id="request-status"></div>
+      <div id="temp-token"></div>
+      <button id="submit" type="submit">Submit</button>
+    </form>
+  </body>
+</html>
+

data/lib/vantiv/environment.rb

@@ -0,0 +1,14 @@
+module Vantiv
+  module Environment
+    PRODUCTION = :production
+    CERTIFICATION = :certification
+
+    def self.production?
+      Vantiv.environment == PRODUCTION
+    end
+
+    def self.certification?
+      Vantiv.environment == CERTIFICATION
+    end
+  end
+end

data/lib/vantiv/mocked_sandbox.rb

@@ -0,0 +1,29 @@
+require 'vantiv/mocked_sandbox/api_request'
+
+module Vantiv
+  module MockedSandbox
+    def self.enable_self_mocked_requests!
+      raise "Usage Error: cannot mock in production" if Vantiv::Environment.production?
+
+      unless Vantiv::Api::Request.instance_methods.include? :orig_run_request
+        Vantiv::Api::Request.send(:alias_method, :orig_run_request, :run_request)
+      end
+      Vantiv::Api::Request.send(:define_method, :run_request) do
+        Vantiv::MockedSandbox::ApiRequest.run(
+          endpoint: endpoint,
+          body: body
+        )
+      end
+    end
+
+    def self.disable_self_mocked_requests!
+      if Vantiv::Api::Request.instance_methods.include? :orig_run_request
+        Vantiv::Api::Request.send(:alias_method, :run_request, :orig_run_request)
+      end
+    end
+
+    def self.fixtures_directory
+      "#{Vantiv.root}/lib/vantiv/mocked_sandbox/fixtures/"
+    end
+  end
+end

data/lib/vantiv/mocked_sandbox/api_request.rb

@@ -0,0 +1,53 @@
+module Vantiv
+  module MockedSandbox
+    class ApiRequest
+      class FixtureNotFound < StandardError; end
+
+      def self.run(endpoint:, body:)
+        new(endpoint, body).run
+      end
+
+      def initialize(endpoint, request_body)
+        self.endpoint = endpoint
+        self.request_body = JSON.parse(request_body)
+      end
+
+      def run
+        if endpoint == Api::Endpoints::TOKENIZATION
+          if direct_post?
+            load_fixture("tokenize_by_direct_post", card_number)
+          end
+        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
+
+      def direct_post?
+        request_body["Card"] && request_body["Card"]["AccountNumber"] != nil
+      end
+
+      def card_number
+        request_body["Card"]["AccountNumber"]
+      end
+
+      def load_fixture(api_method, card_number)
+        begin
+          self.fixture = File.open("#{MockedSandbox.fixtures_directory}#{api_method}--#{card_number}.json.erb", 'r') do |f|
+            raw_fixture = JSON.parse(f.read)
+            raw_fixture["response_body"] = raw_fixture["response_body"].to_json
+            raw_fixture
+          end
+        rescue Errno::ENOENT
+          raise FixtureNotFound.new("Fixture not found for api method: #{api_method}, card number: #{card_number}")
+        end
+      end
+    end
+  end
+end

data/lib/vantiv/mocked_sandbox/fixture_generator.rb

@@ -0,0 +1,48 @@
+module Vantiv
+  module MockedSandbox
+    class FixtureGenerator
+      def self.generate_all
+        TestCard.all.each do |card|
+          new(card: card).run
+        end
+      end
+
+      attr_reader :card
+
+      def initialize(card:)
+        @card = card
+      end
+
+      def run
+        record_tokenize_by_direct_post
+      end
+
+      private
+
+      def record_tokenize_by_direct_post
+        cert_response = Vantiv.tokenize_by_direct_post(
+          card_number: card.card_number,
+          expiry_month: card.expiry_month,
+          expiry_year: card.expiry_year,
+          cvv: card.cvv
+        )
+        dynamic_body = cert_response.body
+        dynamic_body["litleOnlineResponse"]["registerTokenResponse"]["@reportGroup"] = "<%= Vantiv.default_report_group %>"
+        dynamic_body["litleOnlineResponse"]["registerTokenResponse"]["responseTime"] = "<%= Time.now.strftime('%FT%T') %>"
+        dynamic_body["litleOnlineResponse"]["registerTokenResponse"]["TransactionID"] = "<%= rand(10**17) %>"
+        dynamic_body["litleOnlineResponse"]["registerTokenResponse"]["PaymentAccountID"] = "#{card.mocked_sandbox_payment_account_id}"
+        write_fixture_to_file("tokenize_by_direct_post", cert_response, dynamic_body)
+      end
+
+      def write_fixture_to_file(api_method, cert_response, dynamic_body)
+        File.open("#{MockedSandbox.fixtures_directory}/#{api_method}--#{card.card_number}.json.erb", 'w') do |fixture|
+          fixture << JSON.pretty_generate({
+            httpok: cert_response.httpok,
+            http_response_code: cert_response.http_response_code,
+            response_body: dynamic_body
+          })
+        end
+      end
+    end
+  end
+end

data/lib/vantiv/mocked_sandbox/fixtures/tokenize_by_direct_post--4457002100000005.json.erb

@@ -0,0 +1,23 @@
+{
+  "httpok": true,
+  "http_response_code": "200",
+  "response_body": {
+    "litleOnlineResponse": {
+      "@version": "10.2",
+      "@response": "0",
+      "@message": "Valid Format",
+      "registerTokenResponse": {
+        "@id": "3cf703ab2b3151397e69abb8",
+        "@reportGroup": "<%= Vantiv.default_report_group %>",
+        "response": "801",
+        "responseTime": "<%= Time.now.strftime('%FT%T') %>",
+        "message": "Account number was successfully registered",
+        "bin": "445700",
+        "TransactionID": "<%= rand(10**17) %>",
+        "PaymentAccountID": "1111111111120005",
+        "Type": "VI"
+      }
+    },
+    "RequestID": "793636cb-910d-4e28-d4cd-8efd548b6590"
+  }
+}