spree_affirm 0.2.3 → 0.2.19

data/lib/generators/spree_affirm/install/install_generator.rb

@@ -1,21 +0,0 @@
-module SpreeAffirm
-  module Generators
-    class InstallGenerator < Rails::Generators::Base
-
-      class_option :auto_run_migrations, :type => :boolean, :default => false
-
-      def add_migrations
-        run 'bundle exec rake railties:install:migrations FROM=spree_affirm'
-      end
-
-      def run_migrations
-        run_migrations = options[:auto_run_migrations] || ['', 'y', 'Y'].include?(ask 'Would you like to run the migrations now? [Y/n]')
-        if run_migrations
-          run 'bundle exec rake db:migrate'
-        else
-          puts 'Skipping rake db:migrate, don\'t forget to run it!'
-        end
-      end
-    end
-  end
-end

data/lib/spree_affirm.rb

@@ -1,2 +0,0 @@
-require 'spree_core'
-require 'spree_affirm/engine'

data/lib/spree_affirm/engine.rb

@@ -1,27 +0,0 @@
-module SpreeAffirm
-  class Engine < Rails::Engine
-    require 'spree/core'
-    isolate_namespace Spree
-    engine_name 'spree_affirm'
-
-
-    # use rspec for tests
-    config.generators do |g|
-      g.test_framework :rspec
-    end
-
-    config.autoload_paths += %W(#{config.root}/lib)
-
-    def self.activate
-      Dir.glob(File.join(File.dirname(__FILE__), '../../app/**/*_decorator*.rb')) do |c|
-        Rails.configuration.cache_classes ? require(c) : load(c)
-      end
-    end
-
-    config.to_prepare &method(:activate).to_proc
-
-    initializer "spree.spree_affirm.payment_methods", :after => "spree.register.payment_methods" do |app|
-        app.config.spree.payment_methods << Spree::Gateway::Affirm
-    end
-  end
-end

data/lib/spree_affirm/factories.rb

@@ -1,5 +0,0 @@
-require 'factory_girl'
-
-Dir["#{File.dirname(__FILE__)}/factories/**"].each do |f|
-  require File.expand_path(f)
-end

data/lib/spree_affirm/factories/affirm_checkout_factory.rb

@@ -1,211 +0,0 @@
-def BASE_CHECKOUT_DETAILS
-  {
-    "merchant"=> {
-      "public_api_key"=> "PPPPPPPPPPPPPPP",
-      "user_cancel_url"=> "http=>//google.com/cancel",
-      "user_confirmation_url"=> "http=>//google.com/confirm",
-      "name"=> "Test Merchant"
-    },
-    "tax_amount"=> 0,
-    "billing"=> {
-      "address"=> {
-        "city"=> "San Francisco",
-        "street1"=> "12345 Main",
-        "street2"=> "300",
-        "region1_code"=> "AL",
-        "postal_code"=> "55555",
-        "country_code"=> "USA",
-        "for_billing"=> true,
-        "validation_source"=> 3
-      },
-      "email"=> "test@affirm.com",
-      "name"=> {
-        "for_billing"=> true,
-        "last"=> "Doe",
-        "first"=> "John"
-      }
-    },
-    "items"=> {
-      "xxx-xx-xxx-x"=> {
-        "sku"=> "xxx-xx-xxx-x",
-        "item_url"=> "http=>//google.com/products/the-blue-hat",
-        "display_name"=> "The Blue Hat",
-        "unit_price"=> 85000,
-        "qty"=> 1,
-        "item_type"=> "physical",
-        "item_image_url"=> "http=>//google.com/products/6/large/the-blue-hat"
-      }
-    },
-    "shipping"=> {
-      "name"=> {
-        "last"=> "Doe",
-        "first"=> "John"
-      },
-      "address"=> {
-        "city"=> "San Francisco",
-        "street1"=> "12345 Main Street",
-        "street2"=> "300",
-        "region1_code"=> "AL",
-        "postal_code"=> "94110",
-        "country_code"=> "USA",
-        "validation_source"=> 3
-      }
-    },
-    "checkout_id"=> "S123123-456",
-    "currency"=> "USD",
-    "meta"=> {
-      "release"=> "true",
-      "user_timezone"=> "America/Los_Angeles",
-      "__affirm_tracking_uuid"=> "97570a41-cd07-4f52-8869-46c6d2588407"
-    },
-    "discount_code"=> "",
-    "misc_fee_amount"=> 0,
-    "shipping_type"=> "Free National UPS",
-    "config"=> {
-      "required_billing_fields"=> [
-        "name",
-        "address",
-        "email"
-      ]
-    },
-    "api_version"=> "v2",
-    "shipping_amount"=> 0
-  }
-end
-
-FactoryGirl.define do
-  factory :affirm_checkout, class: Spree::AffirmCheckout do
-    token "12345678910"
-    association(:payment_method, factory: :affirm_payment_method)
-    association(:order, factory: :order_with_line_items)
-
-
-    transient do
-      stub_details true
-      shipping_address_mismatch false
-      billing_address_mismatch false
-      alternate_billing_address_format false
-      billing_address_full_name false
-      billing_email_mismatch false
-      extra_line_item false
-      missing_line_item false
-      quantity_mismatch false
-      price_mismatch false
-      full_name_case_mismatch false
-    end
-
-    after(:build) do |checkout, evaluator|
-
-      _details = BASE_CHECKOUT_DETAILS()
-
-      # case mismatch
-      unless evaluator.full_name_case_mismatch
-        _details['billing']['name'] = {
-          "full" => checkout.order.bill_address.firstname.upcase + " " +
-                    checkout.order.bill_address.lastname.upcase
-        }
-      end
-
-      # shipping address
-      unless evaluator.shipping_address_mismatch
-        _details['shipping'] = {
-          "name" => {
-            "first" => checkout.order.ship_address.firstname,
-            "last"  => checkout.order.ship_address.lastname
-          },
-          "address"=> {
-            "city"=> checkout.order.ship_address.city,
-            "street1"=> checkout.order.ship_address.address1,
-            "street2"=> checkout.order.ship_address.address2,
-            "region1_code"=> checkout.order.ship_address.state.abbr,
-            "postal_code"=> checkout.order.ship_address.zipcode,
-            "country_code"=> checkout.order.ship_address.country.iso3
-          }
-        }
-      end
-
-      # billing address
-      unless evaluator.billing_address_mismatch
-        _details["billing"] = {
-          "email" => "joe@schmoe.com",
-          "name" => {
-            "first" => checkout.order.bill_address.firstname,
-            "last"  => checkout.order.bill_address.lastname
-          },
-          "address"=> {
-            "city"=> checkout.order.bill_address.city,
-            "street1"=> checkout.order.bill_address.address1,
-            "street2"=> checkout.order.bill_address.address2,
-            "region1_code"=> checkout.order.bill_address.state.abbr,
-            "postal_code"=> checkout.order.bill_address.zipcode,
-            "country_code"=> checkout.order.bill_address.country.iso3
-          }
-        }
-      end
-
-      # use alternate format for billing address
-      if evaluator.alternate_billing_address_format
-        _details['billing']["address"] = {
-          "city" => _details['billing']["address"]["city"],
-          "line1"=> _details['billing']["address"]["street1"],
-          "line2"=> _details['billing']["address"]["street2"],
-          "state"=> _details['billing']["address"]["postal_code"],
-          "zipcode"=> _details['billing']["address"]["region1_code"],
-          "country"=> _details['billing']["address"]["country_code"]
-        }
-      end
-
-      # use name.full instead of first/last
-      if evaluator.billing_address_full_name
-        _details['billing']['name'] = {
-          'full' => "#{_details['billing']['name']['first']} #{_details['billing']['name']['last']}"
-        }
-      end
-
-
-      # billing email
-      unless evaluator.billing_email_mismatch
-        _details["billing"]["email"] = checkout.order.email
-      end
-
-      # setup items in cart
-      _details['items'] = {}
-      checkout.order.line_items.each do |item|
-        _details['items'][item.variant.sku] = {
-          "qty" => item.quantity.to_s,
-          "unit_price" => (item.price*100).to_s,
-          "display_name" => item.product.name
-        }
-      end
-
-      if evaluator.extra_line_item
-        _details['items']['extra-1-2-3'] = {
-          "qty" => "1",
-          "unit_price" => "12300",
-          "display_name" => "Really cool hat"
-        }
-      end
-
-      if evaluator.missing_line_item
-        _details['items'].delete _details['items'].keys.last
-      end
-
-      if evaluator.quantity_mismatch
-        _last_item = _details['items'][_details['items'].keys.last]
-        _details['items'][_details['items'].keys.last]['qty'] = (_last_item['qty'].to_i + 1).to_s
-      end
-
-      if evaluator.price_mismatch
-        _last_item = _details['items'][_details['items'].keys.last]
-        _details['items'][_details['items'].keys.last]['unit_price'] = 456456
-      end
-
-      if evaluator.stub_details
-        checkout.stub(details: _details)
-      end
-    end
-
-  end
-end
-
-

data/lib/spree_affirm/factories/affirm_payment_method_factory.rb

@@ -1,8 +0,0 @@
-FactoryGirl.define do
-  factory :affirm_payment_method, class: Spree::Gateway::Affirm do
-    name "Staging Affirm Split Pay"
-    active true
-    environment "test"
-    auto_capture false
-  end
-end

data/lib/spree_affirm/factories/payment_factory.rb

@@ -1,10 +0,0 @@
-FactoryGirl.define do
-  factory :affirm_payment, class: Spree::Payment do
-    amount 45.75
-    association(:payment_method, factory: :affirm_payment_method)
-    association(:source, factory: :affirm_checkout)
-    order
-    state 'checkout'
-    response_code '12345'
-  end
-end

data/lib/spree_affirm/version.rb

@@ -1,3 +0,0 @@
-module SpreeAffirm
-  VERSION = "0.2.3"
-end

data/spec/controllers/affirm_controller_spec.rb

@@ -1,138 +0,0 @@
-require 'spec_helper'
-
-describe Spree::AffirmController do
-  let(:user) { FactoryGirl.create(:user) }
-  let(:checkout) { FactoryGirl.build(:affirm_checkout) }
-  let(:bad_billing_checkout) { FactoryGirl.build(:affirm_checkout, billing_address_mismatch: true) }
-  let(:bad_shipping_checkout) { FactoryGirl.build(:affirm_checkout, shipping_address_mismatch: true) }
-  let(:bad_email_checkout) { FactoryGirl.build(:affirm_checkout, billing_email_mismatch: true) }
-
-
-  describe "POST confirm" do
-
-    def post_request(token, payment_id)
-      post :confirm, checkout_token: token, payment_method_id: payment_id, use_route: 'spree'
-    end
-
-    before do
-      controller.stub authenticate_spree_user!: true
-      controller.stub spree_current_user: user
-    end
-
-    context "when the checkout matches the order" do
-      before do
-        Spree::AffirmCheckout.stub new: checkout
-        controller.stub current_order: checkout.order
-      end
-
-      context "when no checkout_token is provided" do
-        it "redirects to the current order state" do
-          post_request(nil, nil)
-          expect(response).to redirect_to(controller.checkout_state_path(checkout.order.state))
-        end
-      end
-
-      context "when the order is complete" do
-        before do
-          checkout.order.state = 'complete'
-        end
-        it "redirects to the current order state" do
-          post_request '123456789', checkout.payment_method.id
-          expect(response).to redirect_to(controller.order_path(checkout.order))
-        end
-      end
-
-      context "when the order state is payment" do
-        before do
-          checkout.order.state = 'payment'
-        end
-
-        it "creates a new payment" do
-          post_request "123423423", checkout.payment_method.id
-
-          expect(checkout.order.payments.first.source).to eq(checkout)
-        end
-
-        # it "transitions to complete if confirmation is not required" do
-        #   checkout.order.stub confirmation_required?: false
-        #   post_request "123423423", checkout.payment_method.id
-
-        #   expect(checkout.order.state).to eq("complete")
-        # end
-
-        it "transitions to confirm if confirmation is required" do
-          checkout.order.stub confirmation_required?: true
-          post_request "123423423", checkout.payment_method.id
-
-          expect(checkout.order.reload.state).to eq("confirm")
-        end
-      end
-
-    end
-
-    context "when the billing_address does not match the order" do
-      before do
-        Spree::AffirmCheckout.stub new: bad_billing_checkout
-        state = FactoryGirl.create(:state, abbr: bad_billing_checkout.details['billing']['address']['region1_code'])
-        Spree::State.stub find_by_abbr: state, find_by_name: state
-        controller.stub current_order: bad_billing_checkout.order
-      end
-
-      it "creates a new address record for the order" do
-        _old_billing_address = bad_billing_checkout.order.bill_address
-        post_request '12345789', bad_billing_checkout.payment_method.id
-
-        expect(bad_billing_checkout.order.bill_address).not_to be(_old_billing_address)
-        expect(bad_billing_checkout.valid?).to be(true)
-      end
-    end
-
-
-    context "when the shipping_address does not match the order" do
-      before do
-        Spree::AffirmCheckout.stub new: bad_shipping_checkout
-        state = FactoryGirl.create(:state, abbr: bad_shipping_checkout.details['shipping']['address']['region1_code'])
-        Spree::State.stub find_by_abbr: state, find_by_name: state
-        controller.stub current_order: bad_shipping_checkout.order
-      end
-
-      it "creates a new address record for the order" do
-        _old_shipping_address = bad_shipping_checkout.order.ship_address
-        post_request '12345789', bad_shipping_checkout.payment_method.id
-
-        expect(bad_shipping_checkout.order.ship_address).not_to be(_old_shipping_address)
-        expect(bad_shipping_checkout.valid?).to be(true)
-      end
-    end
-
-
-
-    context "when the billing_email does not match the order" do
-      before do
-        Spree::AffirmCheckout.stub new: bad_email_checkout
-        controller.stub current_order: bad_email_checkout.order
-      end
-
-      it "updates the billing_email on the order" do
-        _old_email = bad_email_checkout.order.email
-        post_request '12345789', bad_email_checkout.payment_method.id
-
-        expect(bad_email_checkout.order.email).not_to be(_old_email)
-        expect(bad_email_checkout.valid?).to be(true)
-      end
-    end
-
-
-    context "there is no current order" do
-      before(:each) do
-        controller.stub current_order: nil
-      end
-
-      it "raises an ActiveRecord::RecordNotFound error" do
-        expect do
-          post_request nil, nil
-        end.to raise_error(ActiveRecord::RecordNotFound)
-      end
-    end
-  end
-end

data/spec/lib/active_merchant/billing/affirm_spec.rb

@@ -1,294 +0,0 @@
-require 'spec_helper'
-
-
-describe ActiveMerchant::Billing::Affirm do
-  let(:affirm_payment) { FactoryGirl.create(:affirm_payment) }
-  let(:charge_id) { "1234-5678-9012" }
-
-
-  def expect_request(method, url_regexp, data, successful_response=true, response={})
-    affirm_payment.payment_method.provider.should_receive(:ssl_request) { |_method, _url, _data, _headers|
-
-      # check method type
-      _method.should be(method)
-
-      # test path
-      _url.should match(url_regexp) unless url_regexp.nil?
-
-      # test data
-      _data.should eq(data.to_json) unless data.nil?
-
-      # create response
-      _response = (response || {}).reverse_merge({
-        id: charge_id,
-        pending: true,
-        amount: 8000
-      })
-
-      _response[:status_code] = 400 unless successful_response
-
-      _response.to_json
-    }.at_least(1).times
-  end
-
-
-  def expect_request_and_return_success(method, url_regexp, data, response=nil )
-    expect_request(method, url_regexp, data, true, response)
-  end
-
-
-  def expect_request_and_return_failure(method, url_regexp, data, response=nil )
-    expect_request(method, url_regexp, data, false, response)
-  end
-
-
-  def expect_post_and_return_success(url_regexp=nil, data=nil, response=nil )
-    expect_request_and_return_success(:post, url_regexp, data, response)
-  end
-
-
-  def expect_post_and_return_failure(url_regexp=nil, data=nil, response=nil )
-    expect_request_and_return_failure(:post, url_regexp, data, response)
-  end
-
-
-  def expect_get_and_return_success(url_regexp=nil, data=nil, response=nil )
-    expect_request_and_return_success(:get, url_regexp, data, response)
-  end
-
-
-  def expect_get_and_return_failure(url_regexp=nil, data=nil, response=nil )
-    expect_request_and_return_failure(:get, url_regexp, data, response)
-  end
-
-
-
-  describe "#authorize" do
-    it "sends a POST to /api/v2/charges/ with the checkout_token" do
-      expect_post_and_return_success(/\/api\/v2\/charges/, {checkout_token: affirm_payment.source.token}, {amount: 8000})
-      affirm_payment.payment_method.provider.authorize(8000, affirm_payment.source)
-    end
-
-
-    context "when the POST response is not successful" do
-      it "returns the result from the POST" do
-        expect_post_and_return_failure nil, nil, {message: "Whoops!"}
-        result = affirm_payment.payment_method.provider.authorize(8000, affirm_payment.source)
-        expect(result.success?).to be(false)
-        expect(result.message).to eq("Whoops!")
-      end
-    end
-
-
-    context "when the POST respone is successful" do
-      context "when the auth amount does not match the given amount" do
-        it "returns an error response for that error" do
-          expect_post_and_return_success(/\/api\/v2\/charges/, {checkout_token: affirm_payment.source.token}, {amount: 9000})
-          result = affirm_payment.payment_method.provider.authorize(1999, affirm_payment.source)
-          expect(result.success?).to be(false)
-          expect(result.message).to eq("Auth amount does not match charge amount")
-        end
-      end
-
-
-      context "when the charge is not pending in the response" do
-        it "returns an error response for that error" do
-          expect_post_and_return_success(/\/api\/v2\/charges/, {checkout_token: affirm_payment.source.token}, {amount: 9000, pending: false})
-          result = affirm_payment.payment_method.provider.authorize(9000, affirm_payment.source)
-          expect(result.success?).to be(false)
-          expect(result.message).to eq("There was an error authorizing this Charge")
-        end
-      end
-
-
-      it "returns the result from the POST" do
-        expect_post_and_return_success(/\/api\/v2\/charges/, {checkout_token: affirm_payment.source.token}, {amount: 9000})
-        result = affirm_payment.payment_method.provider.authorize(9000, affirm_payment.source)
-        expect(result.success?).to be(true)
-        expect(result.params['amount']).to eq(9000)
-      end
-    end
-  end
-
-
-
-  describe "#purchase" do
-    it "authorizes the charge" do
-      expect_post_and_return_failure(/\/api\/v2\/charges/, {checkout_token: affirm_payment.source.token})
-      affirm_payment.payment_method.provider.purchase(8000, affirm_payment.source)
-    end
-
-
-    context "when the authorize response is not successful" do
-      it "returns the response of the auth response" do
-        expect_post_and_return_failure(/\/api\/v2\/charges/, {checkout_token: affirm_payment.source.token})
-        purchase_result = affirm_payment.payment_method.provider.purchase(8000, affirm_payment.source)
-        auth_result     = affirm_payment.payment_method.provider.authorize(8000, affirm_payment.source)
-
-        [:success?, :params, :message].each do |method|
-          expect(purchase_result.send(method)).to eq(auth_result.send(method))
-        end
-      end
-
-
-      it "does not attempt to capture the charge" do
-        expect_post_and_return_failure(/\/api\/v2\/charges/, {checkout_token: affirm_payment.source.token})
-        affirm_payment.payment_method.provider.should_not_receive(:capture)
-        affirm_payment.payment_method.provider.purchase(8000, affirm_payment.source)
-      end
-    end
-
-
-    context "when the authorize response is successful" do
-      it "captures the charge" do
-        expect_post_and_return_success(/\/api\/v2\/charges/, {checkout_token: affirm_payment.source.token})
-        affirm_payment.payment_method.provider.should_receive(:capture)
-        affirm_payment.payment_method.provider.purchase(8000, affirm_payment.source)
-      end
-    end
-  end
-
-
-
-
-  describe "#capture" do
-    it "calls a POST to charges/[charge_ari]/capture" do
-      expect_post_and_return_success(/\/api\/v2\/charges\/#{charge_id}\/capture/, {amount: "8000"})
-      affirm_payment.payment_method.provider.capture(8000, charge_id)
-    end
-
-    context "when the capture response is not successful" do
-      it "returns the response" do
-        expect_post_and_return_failure(/\/api\/v2\/charges\/#{charge_id}\/capture/, {amount: "8000"},
-          message: "buuuuuusted"
-        )
-        result = affirm_payment.payment_method.provider.capture(8000, charge_id)
-        expect(result.success?).to be(false)
-        expect(result.message).to eq("buuuuuusted")
-      end
-    end
-
-
-    context "when the capture response is successful" do
-      it "returns the response" do
-        expect_post_and_return_success(/\/api\/v2\/charges\/#{charge_id}\/capture/, {amount: "8000"},
-          amount: 8000
-        )
-        result = affirm_payment.payment_method.provider.capture(8000, charge_id)
-        expect(result.success?).to be(true)
-        expect(result.params['amount']).to eq(8000)
-      end
-
-
-      context "when the captured amount does not equal the requested amount" do
-        it "returns a failed response" do
-          expect_post_and_return_success(/\/api\/v2\/charges\/#{charge_id}\/capture/, {amount: "8000"},
-            amount: 299
-          )
-          result = affirm_payment.payment_method.provider.capture(8000, charge_id)
-          expect(result.success?).to be(false)
-          expect(result.message).to eq("Capture amount does not match charge amount")
-        end
-      end
-    end
-  end
-
-
-
-  describe "#void" do
-    it "calls POST on /charges/[charge_ari]/void" do
-      expect_post_and_return_success(/\/api\/v2\/charges\/#{charge_id}\/void/)
-      affirm_payment.payment_method.provider.void(charge_id)
-    end
-
-
-    it "returns the response from the POST request" do
-      expect_post_and_return_success(/\/api\/v2\/charges\/#{charge_id}\/void/)
-      result = affirm_payment.payment_method.provider.void(charge_id)
-      expect(result.success?).to be(true)
-      expect(result.message).to eq("Transaction approved")
-    end
-  end
-
-
-
-  describe "#refund" do
-    it "calls POST on /charges/[charge_ari]/refund" do
-      expect_post_and_return_success(/\/api\/v2\/charges\/#{charge_id}\/refund/, {amount: "8000"})
-      affirm_payment.payment_method.provider.refund(8000, charge_id)
-    end
-
-
-    it "returns the response from the POST request" do
-      expect_post_and_return_success(/\/api\/v2\/charges\/#{charge_id}\/refund/, {amount: "8000"})
-      result = affirm_payment.payment_method.provider.refund(8000, charge_id)
-      expect(result.success?).to be(true)
-      expect(result.message).to eq("Transaction approved")
-    end
-  end
-
-
-
-  describe "#credit" do
-    context "when the requested amount is non zero" do
-      it "calls refund with the requested amount" do
-        affirm_payment.payment_method.provider.should_receive(:refund).with(8000, charge_id, {})
-        affirm_payment.payment_method.provider.credit(8000, charge_id)
-      end
-    end
-
-    context "when the requested amount is zero" do
-      it "returns a valid response and does not call refund()" do
-        affirm_payment.payment_method.provider.should_not_receive(:refund)
-        result = affirm_payment.payment_method.provider.credit(0, charge_id)
-        expect(result.success?).to be(true)
-      end
-    end
-  end
-
-
-
-  describe "#get_checkout" do
-    it "makes a GET request to /checkout/[checkout_token]" do
-      expect_get_and_return_success(/\/api\/v2\/checkout\/#{affirm_payment.source.token}/)
-      affirm_payment.payment_method.provider.get_checkout(affirm_payment.source.token)
-    end
-  end
-
-
-  describe "#commit" do
-    context "when a ResponseError is returned" do
-      it "returns an invalid response error" do
-        http_response = double()
-        http_response.stub(:code).and_return('400')
-        http_response.stub(:body).and_return("{}")
-        affirm_payment.payment_method.provider.should_receive(:ssl_request).and_raise ActiveMerchant::ResponseError.new(http_response)
-        result = affirm_payment.payment_method.provider.commit(:post, "test")
-        expect(result.success?).to be(false)
-      end
-
-      context "when the error response has malformed json" do
-        it "returns an invalid response error" do
-          http_response = double()
-          http_response.stub(:code).and_return('400')
-          http_response.stub(:body).and_return("{///xdf2fas!!+")
-          affirm_payment.payment_method.provider.should_receive(:parse).and_raise JSON::ParserError
-          affirm_payment.payment_method.provider.should_receive(:ssl_request).and_raise ActiveMerchant::ResponseError.new(http_response)
-          result = affirm_payment.payment_method.provider.commit(:post, "test")
-          expect(result.success?).to be(false)
-          expect(result.params['error']['message']).to match(/The raw response returned by the API was/)
-        end
-      end
-    end
-
-
-    context "when malformed JSON is returned" do
-      it "returns an invalid response error" do
-        affirm_payment.payment_method.provider.should_receive(:ssl_request).and_raise JSON::ParserError
-        result = affirm_payment.payment_method.provider.commit(:post, "test")
-        expect(result.success?).to be(false)
-        expect(result.params['error']['message']).to match(/The raw response returned by the API was/)
-      end
-    end
-  end
-end