braintree 2.74.0 → 4.12.0

data/lib/braintree/amex_express_checkout_card.rb

@@ -1,26 +0,0 @@
-module Braintree
-  class AmexExpressCheckoutCard
-    include BaseModule # :nodoc:
-
-    attr_reader :bin, :card_member_expiry_date, :card_member_number, :card_type, :created_at, :customer_id, :default,
-      :expiration_month, :expiration_year, :image_url, :source_description, :subscriptions, :token, :updated_at
-
-    def initialize(gateway, attributes) # :nodoc:
-      @gateway = gateway
-      set_instance_variables_from_hash(attributes)
-      @subscriptions = (@subscriptions || []).map { |subscription_hash| Subscription._new(@gateway, subscription_hash) }
-    end
-
-    def default?
-      @default
-    end
-
-    class << self
-      protected :new
-    end
-
-    def self._new(*args) # :nodoc:
-      self.new *args
-    end
-  end
-end

data/lib/braintree/android_pay_card.rb

@@ -1,35 +0,0 @@
-module Braintree
-  class AndroidPayCard
-    include BaseModule # :nodoc:
-
-    attr_reader :token, :virtual_card_type, :virtual_card_last_4, :source_card_type, :source_card_last_4,
-      :expiration_month, :expiration_year, :created_at, :updated_at, :image_url, :subscriptions, :bin,
-      :google_transaction_id, :default, :source_description, :customer_id
-
-    def initialize(gateway, attributes) # :nodoc:
-      @gateway = gateway
-      set_instance_variables_from_hash(attributes)
-      @subscriptions = (@subscriptions || []).map { |subscription_hash| Subscription._new(@gateway, subscription_hash) }
-    end
-
-    def default?
-      @default
-    end
-
-    def card_type
-      virtual_card_type
-    end
-
-    def last_4
-      virtual_card_last_4
-    end
-
-    class << self
-      protected :new
-    end
-
-    def self._new(*args) # :nodoc:
-      self.new *args
-    end
-  end
-end

data/lib/braintree/coinbase_account.rb

@@ -1,25 +0,0 @@
-module Braintree
-  class CoinbaseAccount
-    include BaseModule # :nodoc:
-
-    attr_reader :token, :user_id, :user_email, :user_name, :subscriptions, :created_at, :updated_at, :default, :customer_id
-    def initialize(gateway, attributes) # :nodoc:
-      @gateway = gateway
-      set_instance_variables_from_hash(attributes)
-      @subscriptions = (@subscriptions || []).map { |subscription_hash| Subscription._new(@gateway, subscription_hash) }
-    end
-
-    class << self
-      protected :new
-    end
-
-    def self._new(*args) # :nodoc:
-      self.new *args
-    end
-
-    # Returns true if this coinbase account is the customer's default payment method.
-    def default?
-      @default
-    end
-  end
-end

data/lib/braintree/europe_bank_account.rb

@@ -1,34 +0,0 @@
-module Braintree
-  class EuropeBankAccount
-    include BaseModule
-
-    module MandateType
-      Business = 'business'
-      Consumer = 'consumer'
-    end
-
-    attr_reader :token, :image_url, :customer_id
-
-    def initialize(gateway, attributes) # :nodoc:
-      @gateway = gateway
-      set_instance_variables_from_hash(attributes)
-    end
-
-    class << self
-      protected :new
-    end
-
-    def self._new(*args)
-      self.new(*args)
-    end
-
-    def self.find(token)
-      Configuration.gateway.europe_bank_account.find(token)
-    end
-
-    def default?
-      @default
-    end
-
-  end
-end

data/lib/braintree/europe_bank_account_gateway.rb

@@ -1,17 +0,0 @@
-module Braintree
-  class EuropeBankAccountGateway
-    def initialize(gateway)
-      @gateway = gateway
-      @config = gateway.config
-      @config.assert_has_access_token_or_keys
-    end
-
-    def find(token)
-      raise ArgumentError if token.nil? || token.to_s.strip == ""
-      response = @config.http.get("#{@config.base_merchant_path}/payment_methods/europe_bank_account/#{token}")
-      EuropeBankAccount._new(@gateway, response[:europe_bank_account])
-    rescue NotFoundError
-      raise NotFoundError, "payment method with token #{token.inspect} not found"
-    end
-  end
-end

data/lib/braintree/ideal_payment.rb

@@ -1,46 +0,0 @@
-module Braintree
-  class IdealPayment
-    include BaseModule
-
-    attr_reader :id, :ideal_transaction_id, :currency, :amount, :status, :order_id, :issuer, :approval_url, :iban_bank_account
-
-    def initialize(gateway, attributes) # :nodoc:
-      @gateway = gateway
-      set_instance_variables_from_hash(attributes)
-      @iban_bank_account = IbanBankAccount.new(attributes[:iban_bank_account]) if attributes[:iban_bank_account]
-    end
-
-    class << self
-      protected :new
-    end
-
-    def self._new(*args) # :nodoc:
-      self.new *args
-    end
-
-    def self.sale(ideal_payment_id, transaction_attributes)
-      Configuration.gateway.transaction.sale(transaction_attributes.merge(
-            :payment_method_nonce => ideal_payment_id,
-            :options => { :submit_for_settlement => true }
-          )
-        )
-    end
-
-    def self.sale!(ideal_payment_id, transaction_attributes)
-      return_object_or_raise(:transaction) { sale(ideal_payment_id, transaction_attributes) }
-    end
-
-    def self.find(ideal_payment_id)
-      Configuration.gateway.ideal_payment.find(ideal_payment_id)
-    end
-
-    class IbanBankAccount
-      include BaseModule
-      attr_reader :account_holder_name, :bic, :masked_iban, :iban_account_number_last_4, :iban_country, :description
-
-      def initialize(attributes) # :nodoc:
-        set_instance_variables_from_hash(attributes)
-      end
-    end
-  end
-end

data/lib/braintree/ideal_payment_gateway.rb

@@ -1,18 +0,0 @@
-module Braintree
-  class IdealPaymentGateway
-    def initialize(gateway)
-      @gateway = gateway
-      @config = gateway.config
-      @config.assert_has_access_token_or_keys
-    end
-
-    def find(ideal_payment_id)
-      raise ArgumentError if ideal_payment_id.nil? || ideal_payment_id.to_s.strip == ""
-      response = @config.http.get("#{@config.base_merchant_path}/ideal_payments/#{ideal_payment_id}")
-      IdealPayment._new(@gateway, response[:ideal_payment])
-    rescue NotFoundError
-      raise NotFoundError, "ideal payment with ideal_payment_id #{ideal_payment_id.inspect} not found"
-    end
-
-  end
-end

data/lib/braintree/masterpass_card.rb

@@ -1,66 +0,0 @@
-module Braintree
-  class MasterpassCard
-    include BaseModule # :nodoc:
-
-    attr_reader :billing_address, :bin, :card_type, :cardholder_name,
-      :commercial, :country_of_issuance, :created_at, :customer_id,
-      :customer_location, :debit, :durbin_regulated, :expiration_month,
-      :expiration_year, :healthcare, :issuing_bank, :last_4, :payroll,
-      :prepaid, :product_id, :subscriptions, :token, :unique_number_identifier,
-      :updated_at, :image_url, :verification
-
-    def initialize(gateway, attributes) # :nodoc:
-      @gateway = gateway
-      set_instance_variables_from_hash(attributes)
-      @billing_address = attributes[:billing_address] ? Address._new(@gateway, attributes[:billing_address]) : nil
-      @subscriptions = (@subscriptions || []).map { |subscription_hash| Subscription._new(@gateway, subscription_hash) }
-      @verification = _most_recent_verification(attributes)
-    end
-
-    def _most_recent_verification(attributes)
-      verification = (attributes[:verifications] || []).sort_by{ |verification| verification[:created_at] }.reverse.first
-      CreditCardVerification._new(verification) if verification
-    end
-
-    def default?
-      @default
-    end
-
-    # Expiration date formatted as MM/YYYY
-    def expiration_date
-      "#{expiration_month}/#{expiration_year}"
-    end
-
-    def expired?
-      @expired
-    end
-
-    def ==(other)
-      return false unless other.is_a?(MasterpassCard)
-      token == other.token
-    end
-
-    def inspect # :nodoc:
-      first = [:token]
-      order = first + (self.class._attributes - first)
-      nice_attributes = order.map do |attr|
-        "#{attr}: #{send(attr).inspect}"
-      end
-      "#<#{self.class} #{nice_attributes.join(', ')}>"
-    end
-
-    def self._attributes # :nodoc:
-      [
-        :billing_address, :bin, :card_type, :cardholder_name, :created_at,
-        :customer_id, :customer_location, :expiration_month, :expiration_year,
-        :last_4, :token, :updated_at, :prepaid, :payroll, :product_id,
-        :commercial, :debit, :durbin_regulated, :healthcare,
-        :country_of_issuance, :issuing_bank, :image_url
-      ]
-    end
-
-    def self._new(*args) # :nodoc:
-      self.new *args
-    end
-  end
-end

data/lib/braintree/transaction/amex_express_checkout_details.rb

@@ -1,14 +0,0 @@
-module Braintree
-  class Transaction
-    class AmexExpressCheckoutDetails
-      include BaseModule
-
-      attr_reader :card_type, :token, :bin, :expiration_month, :expiration_year,
-        :card_member_number, :card_member_expiry_date, :image_url, :source_description
-
-      def initialize(attributes)
-        set_instance_variables_from_hash attributes unless attributes.nil?
-      end
-    end
-  end
-end

data/lib/braintree/transaction/android_pay_details.rb

@@ -1,17 +0,0 @@
-module Braintree
-  class Transaction
-    class AndroidPayDetails
-      include BaseModule
-
-      attr_reader :card_type, :last_4, :expiration_month, :expiration_year,
-        :google_transaction_id, :virtual_card_type, :virtual_card_last_4,
-        :source_card_type, :source_card_last_4, :source_description
-
-      def initialize(attributes)
-        set_instance_variables_from_hash attributes unless attributes.nil?
-        @card_type = @virtual_card_type
-        @last_4 = @virtual_card_last_4
-      end
-    end
-  end
-end

data/lib/braintree/transaction/ideal_payment_details.rb

@@ -1,13 +0,0 @@
-module Braintree
-  class Transaction
-    class IdealPaymentDetails # :nodoc:
-      include BaseModule
-
-      attr_reader :ideal_payment_id, :ideal_transaction_id, :masked_iban, :bic, :image_url
-
-      def initialize(attributes)
-        set_instance_variables_from_hash attributes unless attributes.nil?
-      end
-    end
-  end
-end

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(query_string)
-      Configuration.gateway.transparent_redirect.confirm(query_string)
-    end
-
-    def self.create_credit_card_data(params)
-      Configuration.gateway.transparent_redirect.create_credit_card_data(params)
-    end
-
-    def self.create_customer_data(params)
-      Configuration.gateway.transparent_redirect.create_customer_data(params)
-    end
-
-    def self.transaction_data(params)
-      Configuration.gateway.transparent_redirect.transaction_data(params)
-    end
-
-    def self.update_credit_card_data(params)
-      Configuration.gateway.transparent_redirect.update_credit_card_data(params)
-    end
-
-    def self.update_customer_data(params)
-      Configuration.gateway.transparent_redirect.update_customer_data(params)
-    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/httpsd.pid

@@ -1 +0,0 @@
-15408

data/spec/integration/braintree/coinbase_spec.rb

@@ -1,31 +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 "works for transaction#create" do
-    result = Braintree::Transaction.sale(:payment_method_nonce => Braintree::Test::Nonce::Coinbase, :amount => "0.02")
-    result.should be_success
-    assert_valid_coinbase_attrs(result.transaction.coinbase_details)
-  end
-
-  it "works for vaulting" do
-    customer = Braintree::Customer.create!
-    vaulted = Braintree::PaymentMethod.create(:customer_id => customer.id, :payment_method_nonce => Braintree::Test::Nonce::Coinbase).payment_method
-    assert_valid_coinbase_attrs(vaulted)
-
-    found = Braintree::PaymentMethod.find(vaulted.token).payment_method
-    assert_valid_coinbase_attrs(found)
-  end
-
-  it "is returned on Customers" do
-    customer = Braintree::Customer.create!(:payment_method_nonce => Braintree::Test::Nonce::Coinbase)
-    customer.payment_methods.should == customer.coinbase_accounts
-    assert_valid_coinbase_attrs(customer.coinbase_accounts[0])
-  end
-end

data/spec/integration/braintree/ideal_payment_spec.rb

@@ -1,87 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
-require File.expand_path(File.dirname(__FILE__) + "/client_api/spec_helper")
-
-describe Braintree::IdealPayment do
-  context "self.sale" do
-    it "creates a transaction using an Ideal payment token and returns a result object" do
-      ideal_payment_id = generate_valid_ideal_payment_nonce
-
-      result = Braintree::IdealPayment.sale(
-        ideal_payment_id,
-        :order_id => SpecHelper::DefaultOrderId,
-        :merchant_account_id => "ideal_merchant_account",
-        :amount => Braintree::Test::TransactionAmounts::Authorize
-      )
-
-      result.success?.should == true
-      result.transaction.amount.should == BigDecimal.new(Braintree::Test::TransactionAmounts::Authorize)
-      result.transaction.type.should == "sale"
-      ideal_payment_details = result.transaction.ideal_payment_details
-      ideal_payment_details.ideal_payment_id.should =~ /^idealpayment_\w{6,}$/
-      ideal_payment_details.ideal_transaction_id.should =~ /^\d{16,}$/
-      ideal_payment_details.image_url.should start_with("https://")
-      ideal_payment_details.masked_iban.should_not be_empty
-      ideal_payment_details.bic.should_not be_empty
-    end
-  end
-
-  context "self.sale!" do
-    it "creates a transaction using an ideal payment and returns a result object" do
-      ideal_payment_id = generate_valid_ideal_payment_nonce
-
-      transaction = Braintree::IdealPayment.sale!(
-        ideal_payment_id,
-        :order_id => SpecHelper::DefaultOrderId,
-        :merchant_account_id => "ideal_merchant_account",
-        :amount => Braintree::Test::TransactionAmounts::Authorize
-      )
-
-      transaction.amount.should == BigDecimal.new(Braintree::Test::TransactionAmounts::Authorize)
-      transaction.type.should == "sale"
-      ideal_payment_details = transaction.ideal_payment_details
-      ideal_payment_details.ideal_payment_id.should =~ /^idealpayment_\w{6,}$/
-      ideal_payment_details.ideal_transaction_id.should =~ /^\d{16,}$/
-      ideal_payment_details.image_url.should start_with("https://")
-      ideal_payment_details.masked_iban.should_not be_empty
-      ideal_payment_details.bic.should_not be_empty
-    end
-
-    it "does not create a transaction using an ideal payment and returns raises an exception" do
-      expect do
-        Braintree::IdealPayment.sale!(
-          "invalid_nonce",
-          :merchant_account_id => "ideal_merchant_account",
-          :amount => Braintree::Test::TransactionAmounts::Authorize
-        )
-      end.to raise_error(Braintree::ValidationsFailed)
-    end
-  end
-
-  context "self.find" do
-    it "finds the Ideal payment with an id" do
-      ideal_payment_id = generate_valid_ideal_payment_nonce
-      ideal_payment = Braintree::IdealPayment.find(ideal_payment_id)
-
-      ideal_payment.id.should =~ /^idealpayment_\w{6,}$/
-      ideal_payment.ideal_transaction_id.should =~ /^\d{16,}$/
-      ideal_payment.currency.should_not be_empty
-      ideal_payment.amount.should_not be_empty
-      ideal_payment.status.should_not be_empty
-      ideal_payment.order_id.should_not be_empty
-      ideal_payment.issuer.should_not be_empty
-      ideal_payment.approval_url.should start_with("https://")
-      ideal_payment.iban_bank_account.account_holder_name.should_not be_empty
-      ideal_payment.iban_bank_account.bic.should_not be_empty
-      ideal_payment.iban_bank_account.masked_iban.should_not be_empty
-      ideal_payment.iban_bank_account.iban_account_number_last_4.should =~ /^\d{4}$/
-      ideal_payment.iban_bank_account.iban_country.should_not be_empty
-      ideal_payment.iban_bank_account.description.should_not be_empty
-    end
-
-    it "raises if the Ideal payment is not found" do
-      expect do
-        Braintree::IdealPayment.find("idealpayment_nxyqkq_s654wq_92jr64_mnr4kr_yjz")
-      end.to raise_error(Braintree::NotFoundError)
-    end
-  end
-end