braintree 2.104.0 → 4.9.0

data/lib/braintree/transparent_redirect.rb

@@ -1,40 +0,0 @@
-module Braintree
-  module TransparentRedirect
-    module Kind # :nodoc:
-      CreateCustomer = "create_customer"
-      UpdateCustomer = "update_customer"
-      CreatePaymentMethod = "create_payment_method"
-      UpdatePaymentMethod = "update_payment_method"
-      CreateTransaction = "create_transaction"
-    end
-
-    def self.confirm(*args)
-      Configuration.gateway.transparent_redirect.confirm(*args)
-    end
-
-    def self.create_credit_card_data(*args)
-      Configuration.gateway.transparent_redirect.create_credit_card_data(*args)
-    end
-
-    def self.create_customer_data(*args)
-      Configuration.gateway.transparent_redirect.create_customer_data(*args)
-    end
-
-    def self.transaction_data(*args)
-      Configuration.gateway.transparent_redirect.transaction_data(*args)
-    end
-
-    def self.update_credit_card_data(*args)
-      Configuration.gateway.transparent_redirect.update_credit_card_data(*args)
-    end
-
-    def self.update_customer_data(*args)
-      Configuration.gateway.transparent_redirect.update_customer_data(*args)
-    end
-
-    # Returns the URL to which Transparent Redirect Requests should be posted
-    def self.url
-      Configuration.gateway.transparent_redirect.url
-    end
-  end
-end

data/lib/braintree/transparent_redirect_gateway.rb

@@ -1,105 +0,0 @@
-module Braintree
-  class TransparentRedirectGateway # :nodoc
-    TransparentRedirectKeys = [:redirect_url] # :nodoc:
-    CreateCustomerSignature = TransparentRedirectKeys + [{:customer => CustomerGateway._create_signature}] # :nodoc:
-    UpdateCustomerSignature = TransparentRedirectKeys + [:customer_id, {:customer => CustomerGateway._update_signature}] # :nodoc:
-    TransactionSignature = TransparentRedirectKeys + [{:transaction => TransactionGateway._create_signature}] # :nodoc:
-    CreateCreditCardSignature = TransparentRedirectKeys + [{:credit_card => CreditCardGateway._create_signature}] # :nodoc:
-    UpdateCreditCardSignature = TransparentRedirectKeys + [:payment_method_token, {:credit_card => CreditCardGateway._update_signature}] # :nodoc:
-
-    def initialize(gateway)
-      @gateway = gateway
-      @config = gateway.config
-      @config.assert_has_access_token_or_keys
-    end
-
-    def confirm(query_string)
-      params = @gateway.transparent_redirect.parse_and_validate_query_string query_string
-      confirmation_gateway = {
-        TransparentRedirect::Kind::CreateCustomer => :customer,
-        TransparentRedirect::Kind::UpdateCustomer => :customer,
-        TransparentRedirect::Kind::CreatePaymentMethod => :credit_card,
-        TransparentRedirect::Kind::UpdatePaymentMethod => :credit_card,
-        TransparentRedirect::Kind::CreateTransaction => :transaction
-      }[params[:kind]]
-
-      @gateway.send(confirmation_gateway)._do_create("/transparent_redirect_requests/#{params[:id]}/confirm")
-    end
-
-    def create_credit_card_data(params)
-      Util.verify_keys(CreateCreditCardSignature, params)
-      params[:kind] = TransparentRedirect::Kind::CreatePaymentMethod
-      _data(params)
-    end
-
-    def create_customer_data(params)
-      Util.verify_keys(CreateCustomerSignature, params)
-      params[:kind] = TransparentRedirect::Kind::CreateCustomer
-      _data(params)
-    end
-
-    def parse_and_validate_query_string(query_string) # :nodoc:
-      params = Util.symbolize_keys(Util.parse_query_string(query_string))
-      query_string_without_hash = query_string.split("&").reject{|param| param =~ /\Ahash=/}.join("&")
-      decoded_query_string_without_hash = Util.url_decode(query_string_without_hash)
-      encoded_query_string_without_hash = Util.url_encode(query_string_without_hash)
-
-      if params[:http_status] == nil
-        raise UnexpectedError, "expected query string to have an http_status param"
-      elsif params[:http_status] != '200'
-        Util.raise_exception_for_status_code(params[:http_status], params[:bt_message])
-      end
-
-      query_strings_without_hash = [query_string_without_hash, encoded_query_string_without_hash, decoded_query_string_without_hash]
-
-      if query_strings_without_hash.any? { |query_string| @config.signature_service.hash(query_string) == params[:hash] }
-        params
-      else
-        raise ForgedQueryString
-      end
-    end
-
-    def transaction_data(params)
-      Util.verify_keys(TransactionSignature, params)
-      params[:kind] = TransparentRedirect::Kind::CreateTransaction
-      transaction_type = params[:transaction] && params[:transaction][:type]
-      unless %w[sale credit].include?(transaction_type)
-        raise ArgumentError, "expected transaction[type] of sale or credit, was: #{transaction_type.inspect}"
-      end
-      _data(params)
-    end
-
-    def update_credit_card_data(params)
-      Util.verify_keys(UpdateCreditCardSignature, params)
-      unless params[:payment_method_token]
-        raise ArgumentError, "expected params to contain :payment_method_token of payment method to update"
-      end
-      params[:kind] = TransparentRedirect::Kind::UpdatePaymentMethod
-      _data(params)
-    end
-
-    def update_customer_data(params)
-      Util.verify_keys(UpdateCustomerSignature, params)
-      unless params[:customer_id]
-        raise ArgumentError, "expected params to contain :customer_id of customer to update"
-      end
-      params[:kind] = TransparentRedirect::Kind::UpdateCustomer
-      _data(params)
-    end
-
-    def url
-      "#{@config.base_merchant_url}/transparent_redirect_requests"
-    end
-
-    def _data(params) # :nodoc:
-      raise ArgumentError, "expected params to contain :redirect_url" unless params[:redirect_url]
-
-      @config.signature_service.sign(params.merge(
-        :api_version => @config.api_version,
-        :time => Time.now.utc.strftime("%Y%m%d%H%M%S"),
-        :public_key => @config.public_key
-      ))
-    end
-  end
-end
-

data/spec/hacks/tcp_socket.rb

@@ -1,18 +0,0 @@
-require 'timeout'
-require 'socket'
-
-TCPSocket.class_eval do
-  def self.wait_for_service(options)
-    Timeout::timeout(options[:timeout] || 20) do
-      loop do
-        begin
-          socket = TCPSocket.new(options[:host], options[:port])
-          socket.close
-          return
-        rescue Errno::ECONNREFUSED
-          sleep 0.5
-        end
-      end
-    end
-  end
-end

data/spec/integration/braintree/coinbase_spec.rb

@@ -1,34 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
-
-describe "Coinbase" do
-
-  def assert_valid_coinbase_attrs(account_or_details)
-    [:user_id, :user_name, :user_email].each do |attr|
-      [nil,""].should_not include(account_or_details.send(attr))
-    end
-  end
-
-  it "is no longer supported with transaction#create" do
-    result = Braintree::Transaction.sale(:payment_method_nonce => Braintree::Test::Nonce::Coinbase, :amount => "0.02")
-    result.should_not be_success
-
-    result.errors.for(:transaction).first.code.should == Braintree::ErrorCodes::PaymentMethod::PaymentMethodNoLongerSupported
-  end
-
-  it "is no longer supported for vaulting" do
-    customer = Braintree::Customer.create!
-    result = Braintree::PaymentMethod.create(:customer_id => customer.id, :payment_method_nonce => Braintree::Test::Nonce::Coinbase)
-    result.should_not be_success
-
-    result.errors.for(:coinbase_account).first.code.should == Braintree::ErrorCodes::PaymentMethod::PaymentMethodNoLongerSupported
-  end
-
-  it "is no longer supported when creating a Customer with a Coinbase payment method nonce" do
-    expect do
-      Braintree::Customer.create!(:payment_method_nonce => Braintree::Test::Nonce::Coinbase)
-    end.to raise_error { |error|
-      error.should be_a(Braintree::ValidationsFailed)
-      error.error_result.errors.for(:coinbase_account).first.code.should == Braintree::ErrorCodes::PaymentMethod::PaymentMethodNoLongerSupported
-    }
-  end
-end

data/spec/integration/braintree/masterpass_card_spec.rb

@@ -1,97 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
-require File.expand_path(File.dirname(__FILE__) + "/client_api/spec_helper")
-
-describe Braintree::MasterpassCard do
-  it "can create from a payment method nonce" do
-    customer = Braintree::Customer.create!
-
-    result = Braintree::PaymentMethod.create(
-      :payment_method_nonce => Braintree::Test::Nonce::MasterpassDiscover,
-      :customer_id => customer.id
-    )
-    result.should be_success
-
-    masterpass_card = result.payment_method
-    masterpass_card.should be_a(Braintree::MasterpassCard)
-    masterpass_card.billing_address.should_not be_nil
-    masterpass_card.bin.should_not be_nil
-    masterpass_card.card_type.should_not be_nil
-    masterpass_card.cardholder_name.should_not be_nil
-    masterpass_card.commercial.should_not be_nil
-    masterpass_card.country_of_issuance.should_not be_nil
-    masterpass_card.created_at.should_not be_nil
-    masterpass_card.customer_id.should_not be_nil
-    masterpass_card.customer_location.should_not be_nil
-    masterpass_card.debit.should_not be_nil
-    masterpass_card.default?.should_not be_nil
-    masterpass_card.durbin_regulated.should_not be_nil
-    masterpass_card.expiration_date.should_not be_nil
-    masterpass_card.expiration_month.should_not be_nil
-    masterpass_card.expiration_year.should_not be_nil
-    masterpass_card.expired?.should_not be_nil
-    masterpass_card.healthcare.should_not be_nil
-    masterpass_card.image_url.should_not be_nil
-    masterpass_card.issuing_bank.should_not be_nil
-    masterpass_card.last_4.should_not be_nil
-    masterpass_card.payroll.should_not be_nil
-    masterpass_card.prepaid.should_not be_nil
-    masterpass_card.product_id.should_not be_nil
-    masterpass_card.subscriptions.should_not be_nil
-    masterpass_card.token.should_not be_nil
-    masterpass_card.unique_number_identifier.should_not be_nil
-    masterpass_card.updated_at.should_not be_nil
-
-    customer = Braintree::Customer.find(customer.id)
-    customer.masterpass_cards.size.should == 1
-    customer.masterpass_cards.first.should == masterpass_card
-  end
-
-  it "can search for transactions" do
-    transaction_create_result = Braintree::Transaction.sale(
-      :payment_method_nonce => Braintree::Test::Nonce::MasterpassDiscover,
-      :amount => '47.00',
-    )
-    transaction_create_result.should be_success
-    transaction_id = transaction_create_result.transaction.id
-
-    search_results = Braintree::Transaction.search do |search|
-      search.id.is transaction_id
-      search.payment_instrument_type.is Braintree::PaymentInstrumentType::MasterpassCard
-    end
-    search_results.first.id.should == transaction_id
-  end
-
-  it "can create transaction from nonce and vault" do
-    customer = Braintree::Customer.create!
-
-    result = Braintree::Transaction.sale(
-      :payment_method_nonce => Braintree::Test::Nonce::MasterpassDiscover,
-      :customer_id => customer.id,
-      :amount => '47.00',
-      :options => { :store_in_vault => true },
-    )
-    result.should be_success
-
-    masterpass_card_details = result.transaction.masterpass_card_details
-    masterpass_card_details.bin.should_not be_nil
-    masterpass_card_details.card_type.should_not be_nil
-    masterpass_card_details.cardholder_name.should_not be_nil
-    masterpass_card_details.commercial.should_not be_nil
-    masterpass_card_details.country_of_issuance.should_not be_nil
-    masterpass_card_details.customer_location.should_not be_nil
-    masterpass_card_details.debit.should_not be_nil
-    masterpass_card_details.durbin_regulated.should_not be_nil
-    masterpass_card_details.expiration_date.should_not be_nil
-    masterpass_card_details.expiration_month.should_not be_nil
-    masterpass_card_details.expiration_year.should_not be_nil
-    masterpass_card_details.healthcare.should_not be_nil
-    masterpass_card_details.image_url.should_not be_nil
-    masterpass_card_details.issuing_bank.should_not be_nil
-    masterpass_card_details.last_4.should_not be_nil
-    masterpass_card_details.payroll.should_not be_nil
-    masterpass_card_details.prepaid.should_not be_nil
-    masterpass_card_details.product_id.should_not be_nil
-    masterpass_card_details.token.should_not be_nil
-  end
-end
-

data/spec/integration/braintree/transparent_redirect_spec.rb

@@ -1,268 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
-
-describe Braintree::TransparentRedirect do
-  it "raises a DownForMaintenanceError when app is in maintenance mode on TR requests" do
-    tr_data = Braintree::TransparentRedirect.create_customer_data({:redirect_url => "http://example.com"}.merge({}))
-    query_string_response = SpecHelper.simulate_form_post_for_tr(tr_data, {}, Braintree::Configuration.instantiate.base_merchant_url + "/test/maintenance")
-    expect do
-      Braintree::Customer.create_from_transparent_redirect(query_string_response)
-    end.to raise_error(Braintree::DownForMaintenanceError)
-  end
-
-  it "raises a DownForMaintenanceError when the request times out", :if => ENV['UNICORN'] do
-    tr_data = Braintree::TransparentRedirect.create_customer_data({:redirect_url => "http://example.com"}.merge({}))
-    query_string_response = SpecHelper.simulate_form_post_for_tr(tr_data, {}, Braintree::Configuration.instantiate.base_merchant_url + "/test/die")
-    expect do
-      Braintree::Customer.create_from_transparent_redirect(query_string_response)
-    end.to raise_error(Braintree::DownForMaintenanceError)
-  end
-
-  it "raises an AuthenticationError when authentication fails on TR requests" do
-    SpecHelper.using_configuration(:private_key => "incorrect") do
-      tr_data = Braintree::TransparentRedirect.create_customer_data({:redirect_url => "http://example.com"}.merge({}))
-      query_string_response = SpecHelper.simulate_form_post_for_tr(tr_data, {}, Braintree::Customer.create_customer_url)
-      expect do
-        Braintree::Customer.create_from_transparent_redirect(query_string_response)
-      end.to raise_error(Braintree::AuthenticationError)
-    end
-  end
-
-  describe "self.confirm" do
-    context "transaction" do
-      it "successfully confirms a transaction create" do
-        params = {
-          :transaction => {
-            :amount => Braintree::Test::TransactionAmounts::Authorize,
-            :credit_card => {
-              :number => Braintree::Test::CreditCardNumbers::Visa,
-              :expiration_date => "05/2009"
-            }
-          }
-        }
-        tr_data_params = {
-          :transaction => {
-            :type => "sale"
-          }
-        }
-        tr_data = Braintree::TransparentRedirect.transaction_data({:redirect_url => "http://example.com"}.merge(tr_data_params))
-        query_string_response = SpecHelper.simulate_form_post_for_tr(tr_data, params)
-        result = Braintree::TransparentRedirect.confirm(query_string_response)
-
-        result.success?.should == true
-        transaction = result.transaction
-        transaction.type.should == "sale"
-        transaction.amount.should == BigDecimal("1000.00")
-        transaction.credit_card_details.bin.should == Braintree::Test::CreditCardNumbers::Visa[0, 6]
-        transaction.credit_card_details.last_4.should == Braintree::Test::CreditCardNumbers::Visa[-4..-1]
-        transaction.credit_card_details.expiration_date.should == "05/2009"
-      end
-
-      it "allows specifying a service fee" do
-        params = {
-          :transaction => {
-            :amount => Braintree::Test::TransactionAmounts::Authorize,
-            :merchant_account_id => SpecHelper::NonDefaultSubMerchantAccountId,
-            :credit_card => {
-              :number => Braintree::Test::CreditCardNumbers::Visa,
-              :expiration_date => "05/2009"
-            },
-            :service_fee_amount => "1.00"
-          }
-        }
-        tr_data_params = {
-          :transaction => {
-            :type => "sale"
-          }
-        }
-        tr_data = Braintree::TransparentRedirect.transaction_data({:redirect_url => "http://example.com"}.merge(tr_data_params))
-        query_string_response = SpecHelper.simulate_form_post_for_tr(tr_data, params)
-        result = Braintree::TransparentRedirect.confirm(query_string_response)
-        result.success?.should == true
-        result.transaction.service_fee_amount.should == BigDecimal("1.00")
-      end
-
-      it "returns an error when there's an error" do
-        params = {
-          :transaction => {
-            :amount => Braintree::Test::TransactionAmounts::Authorize,
-            :credit_card => {
-              :number => "abc",
-              :expiration_date => "05/2009"
-            }
-          }
-        }
-        tr_data_params = {
-          :transaction => {
-            :type => "sale"
-          }
-        }
-        tr_data = Braintree::TransparentRedirect.transaction_data({:redirect_url => "http://example.com"}.merge(tr_data_params))
-        query_string_response = SpecHelper.simulate_form_post_for_tr(tr_data, params)
-        result = Braintree::TransparentRedirect.confirm(query_string_response)
-
-        result.success?.should == false
-        result.errors.for(:transaction).for(:credit_card).on(:number).size.should > 0
-      end
-    end
-
-    context "customer" do
-      it "successfully confirms a customer create" do
-        params = {
-          :customer => {
-            :first_name => "John",
-          }
-        }
-        tr_data_params = {
-          :customer => {
-            :last_name => "Doe",
-          }
-        }
-        tr_data = Braintree::TransparentRedirect.create_customer_data({:redirect_url => "http://example.com"}.merge(tr_data_params))
-        query_string_response = SpecHelper.simulate_form_post_for_tr(tr_data, params)
-        result = Braintree::TransparentRedirect.confirm(query_string_response)
-
-        result.success?.should == true
-        customer = result.customer
-        customer.first_name.should == "John"
-        customer.last_name.should == "Doe"
-      end
-
-      it "successfully confirms a customer update" do
-        customer = Braintree::Customer.create(
-          :first_name => "Joe",
-          :last_name => "Cool"
-        ).customer
-
-        params = {
-          :customer => {
-            :first_name => "John",
-          }
-        }
-        tr_data_params = {
-          :customer_id => customer.id,
-          :customer => {
-            :last_name => "Uncool",
-          }
-        }
-        tr_data = Braintree::TransparentRedirect.update_customer_data({:redirect_url => "http://example.com"}.merge(tr_data_params))
-        query_string_response = SpecHelper.simulate_form_post_for_tr(tr_data, params)
-        result = Braintree::TransparentRedirect.confirm(query_string_response)
-
-        result.success?.should == true
-        customer = Braintree::Customer.find(customer.id)
-        customer.first_name.should == "John"
-        customer.last_name.should == "Uncool"
-      end
-
-      it "returns an error result when there are errors" do
-        params = {
-          :customer => {
-            :first_name => "John",
-          }
-        }
-        tr_data_params = {
-          :customer => {
-            :last_name => "Doe",
-            :email => "invalid"
-          }
-        }
-        tr_data = Braintree::TransparentRedirect.create_customer_data({:redirect_url => "http://example.com"}.merge(tr_data_params))
-        query_string_response = SpecHelper.simulate_form_post_for_tr(tr_data, params)
-        result = Braintree::TransparentRedirect.confirm(query_string_response)
-
-        result.success?.should == false
-        result.errors.for(:customer).on(:email).size.should > 0
-      end
-    end
-
-    context "credit_card" do
-      it "successfully confirms a credit_card create" do
-        customer = Braintree::Customer.create(:first_name => "John", :last_name => "Doe").customer
-
-        params = {
-          :credit_card => {
-            :cardholder_name => "John Doe"
-          }
-        }
-        tr_data_params = {
-          :credit_card => {
-            :customer_id => customer.id,
-            :number => Braintree::Test::CreditCardNumbers::Visa,
-            :expiration_date => "10/10"
-          }
-        }
-        tr_data = Braintree::TransparentRedirect.create_credit_card_data(
-          {:redirect_url => "http://example.com"}.merge(tr_data_params)
-        )
-        query_string_response = SpecHelper.simulate_form_post_for_tr(tr_data, params)
-        result = Braintree::TransparentRedirect.confirm(query_string_response)
-
-        result.success?.should == true
-        credit_card = result.credit_card
-        credit_card.cardholder_name.should == "John Doe"
-        credit_card.bin.should == Braintree::Test::CreditCardNumbers::Visa[0, 6]
-        credit_card.last_4.should == Braintree::Test::CreditCardNumbers::Visa[-4..-1]
-        credit_card.expiration_date.should == "10/2010"
-      end
-
-      it "successfully confirms a credit_card update" do
-        customer = Braintree::Customer.create(:first_name => "John", :last_name => "Doe").customer
-        credit_card = Braintree::CreditCard.create(
-          :customer_id => customer.id,
-          :number => Braintree::Test::CreditCardNumbers::Visa,
-          :expiration_date => "10/10"
-        ).credit_card
-
-        params = {
-          :credit_card => {
-            :cardholder_name => "John Doe"
-          }
-        }
-        tr_data_params = {
-          :payment_method_token => credit_card.token,
-          :credit_card => {
-            :number => Braintree::Test::CreditCardNumbers::MasterCard,
-            :expiration_date => "11/11"
-          }
-        }
-        tr_data = Braintree::TransparentRedirect.update_credit_card_data(
-          {:redirect_url => "http://example.com"}.merge(tr_data_params)
-        )
-        query_string_response = SpecHelper.simulate_form_post_for_tr(tr_data, params)
-        result = Braintree::TransparentRedirect.confirm(query_string_response)
-
-        result.success?.should == true
-        credit_card = result.credit_card
-        credit_card.cardholder_name.should == "John Doe"
-        credit_card.bin.should == Braintree::Test::CreditCardNumbers::MasterCard[0, 6]
-        credit_card.last_4.should == Braintree::Test::CreditCardNumbers::MasterCard[-4..-1]
-        credit_card.expiration_date.should == "11/2011"
-      end
-
-      it "returns an error result where there are errors" do
-        customer = Braintree::Customer.create(:first_name => "John", :last_name => "Doe").customer
-
-        params = {
-          :credit_card => {
-            :cardholder_name => "John Doe"
-          }
-        }
-        tr_data_params = {
-          :credit_card => {
-            :customer_id => customer.id,
-            :number => Braintree::Test::CreditCardNumbers::Visa,
-            :expiration_date => "123"
-          }
-        }
-        tr_data = Braintree::TransparentRedirect.create_credit_card_data(
-          {:redirect_url => "http://example.com"}.merge(tr_data_params)
-        )
-        query_string_response = SpecHelper.simulate_form_post_for_tr(tr_data, params)
-        result = Braintree::TransparentRedirect.confirm(query_string_response)
-
-        result.success?.should == false
-        result.errors.for(:credit_card).size.should > 0
-      end
-    end
-  end
-end