braintree 2.104.0 → 3.1.0

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

data/spec/unit/braintree/transparent_redirect_spec.rb

@@ -1,223 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
-
-describe Braintree::TransparentRedirect do
-  describe "self.create_credit_card_data" do
-    it "raises an exception if any keys are invalid" do
-      expect do
-        Braintree::TransparentRedirect.create_credit_card_data(
-          :credit_card => {:number => "ok", :invalid_key => "bad"}
-        )
-      end.to raise_error(ArgumentError, "invalid keys: credit_card[invalid_key]")
-    end
-  end
-
-  describe "self.create_customer_data" do
-    it "raises an exception if any keys are invalid" do
-      expect do
-        Braintree::TransparentRedirect.create_customer_data(
-          :customer => {:first_name => "ok", :invalid_key => "bad"}
-        )
-      end.to raise_error(ArgumentError, "invalid keys: customer[invalid_key]")
-    end
-  end
-
-  describe "self.parse_and_validate_query_string" do
-    it "returns the parsed query string params if the hash is valid" do
-      query_string_without_hash = "one=1&two=2&http_status=200"
-      hash = Braintree::Digest.hexdigest(Braintree::Configuration.private_key, query_string_without_hash)
-
-      query_string_with_hash = "#{query_string_without_hash}&hash=#{hash}"
-      result = Braintree::Configuration.gateway.transparent_redirect.parse_and_validate_query_string query_string_with_hash
-      result.should == {:one => "1", :two => "2", :http_status => "200", :hash => hash}
-    end
-
-    it "returns the parsed query string params if the hash is valid and hash is first parameter" do
-      query_string_without_hash = "one=1&two=2&http_status=200"
-      hash = Braintree::Digest.hexdigest(Braintree::Configuration.private_key, query_string_without_hash)
-
-      query_string_with_hash = "hash=#{hash}&#{query_string_without_hash}"
-      result = Braintree::Configuration.gateway.transparent_redirect.parse_and_validate_query_string query_string_with_hash
-      result.should == {:one => "1", :two => "2", :http_status => "200", :hash => hash}
-    end
-
-    it "returns the parsed query string params regardless of hash position if the hash is valid" do
-      query_string_without_hash = "one=1&two=2&http_status=200"
-      hash = Braintree::Digest.hexdigest(Braintree::Configuration.private_key, query_string_without_hash)
-
-      query_string_with_hash = "one=1&hash=#{hash}&two=2&http_status=200"
-      result = Braintree::Configuration.gateway.transparent_redirect.parse_and_validate_query_string query_string_with_hash
-      result.should == {:one => "1", :two => "2", :http_status => "200", :hash => hash}
-    end
-
-    it "raises Braintree::ForgedQueryString if the hash param is not valid" do
-      query_string_without_hash = "http_status=200&one=1&two=2"
-      hash = Digest::SHA1.hexdigest("invalid#{query_string_without_hash}")
-
-      query_string_with_hash = "#{query_string_without_hash}&hash=#{hash}"
-      expect do
-        Braintree::Configuration.gateway.transparent_redirect.parse_and_validate_query_string query_string_with_hash
-      end.to raise_error(Braintree::ForgedQueryString)
-    end
-
-    it "raises Braintree::ForgedQueryString if hash is missing from the query string" do
-      expect do
-        Braintree::Configuration.gateway.transparent_redirect.parse_and_validate_query_string "http_status=200&query_string=without_a_hash"
-      end.to raise_error(Braintree::ForgedQueryString)
-    end
-
-    it "does not raise Braintree::ForgedQueryString if query string is url encoded" do
-      url_encoded_query_string_without_hash = "http_status%3D200%26nested_param%5Bsub_param%5D%3Dtesting"
-      url_decoded_query_string_without_hash = Braintree::Util.url_decode(url_encoded_query_string_without_hash)
-
-      hash = Braintree::Digest.hexdigest(Braintree::Configuration.private_key, url_decoded_query_string_without_hash)
-
-      url_encoded_query_string = "#{url_encoded_query_string_without_hash}&hash=#{hash}"
-
-      expect do
-        Braintree::Configuration.gateway.transparent_redirect.parse_and_validate_query_string url_encoded_query_string
-      end.to raise_error(Braintree::UnexpectedError)
-    end
-
-    it "does not raise Braintree::ForgedQueryString if query string is url decoded" do
-      url_decoded_query_string_without_hash = "http_status=200&nested_param[sub_param]=testing"
-      url_encoded_query_string_without_hash = Braintree::Util.url_encode(url_decoded_query_string_without_hash)
-
-      hash = Braintree::Digest.hexdigest(Braintree::Configuration.private_key, url_encoded_query_string_without_hash)
-
-      url_decoded_query_string = "#{url_decoded_query_string_without_hash}&hash=#{hash}"
-
-      expect do
-        Braintree::Configuration.gateway.transparent_redirect.parse_and_validate_query_string url_decoded_query_string
-      end.to_not raise_error
-    end
-
-    it "does not raise Braintree::ForgedQueryString if the query string is partially encoded" do
-      url_partially_encoded_query_string_without_hash = "http_status=200&nested_param%5Bsub_param%5D=testing"
-
-      hash = Braintree::Digest.hexdigest(Braintree::Configuration.private_key, url_partially_encoded_query_string_without_hash)
-
-      url_partially_encoded_query_string = "#{url_partially_encoded_query_string_without_hash}&hash=#{hash}"
-
-      expect do
-        Braintree::Configuration.gateway.transparent_redirect.parse_and_validate_query_string url_partially_encoded_query_string
-      end.to_not raise_error
-    end
-
-    it "raises an AuthenticationError if authentication fails" do
-      expect do
-        Braintree::Configuration.gateway.transparent_redirect.parse_and_validate_query_string add_hash_to_query_string("http_status=401")
-      end.to raise_error(Braintree::AuthenticationError)
-    end
-
-    it "raises an AuthorizationError if authorization fails" do
-      expect do
-        Braintree::Configuration.gateway.transparent_redirect.parse_and_validate_query_string add_hash_to_query_string("http_status=403")
-      end.to raise_error(Braintree::AuthorizationError)
-    end
-
-    it "raises an UnexpectedError if http_status is not in query string" do
-      expect do
-        Braintree::Configuration.gateway.transparent_redirect.parse_and_validate_query_string add_hash_to_query_string("no_http_status=x")
-      end.to raise_error(Braintree::UnexpectedError, "expected query string to have an http_status param")
-    end
-
-    it "raises a ServerError if the server 500's" do
-      expect do
-        Braintree::Configuration.gateway.transparent_redirect.parse_and_validate_query_string add_hash_to_query_string("http_status=500")
-      end.to raise_error(Braintree::ServerError)
-    end
-
-    it "raises a DownForMaintenanceError if the server is down for maintenance" do
-      expect do
-        Braintree::Configuration.gateway.transparent_redirect.parse_and_validate_query_string add_hash_to_query_string("http_status=503")
-      end.to raise_error(Braintree::DownForMaintenanceError)
-    end
-
-    it "raises an UnexpectedError if some other code is returned" do
-      expect do
-        Braintree::Configuration.gateway.transparent_redirect.parse_and_validate_query_string add_hash_to_query_string("http_status=600")
-      end.to raise_error(Braintree::UnexpectedError, "Unexpected HTTP_RESPONSE 600")
-    end
-  end
-
-  describe "self.transaction_data" do
-    it "raises an exception if any keys are invalid" do
-      expect do
-        Braintree::TransparentRedirect.transaction_data(
-          :transaction => {:amount => "100.00", :invalid_key => "bad"}
-        )
-      end.to raise_error(ArgumentError, "invalid keys: transaction[invalid_key]")
-    end
-
-    it "raises an exception if not given a type" do
-      expect do
-        Braintree::TransparentRedirect.transaction_data(
-          :redirect_url => "http://example.com",
-          :transaction => {:amount => "100.00"}
-        )
-      end.to raise_error(ArgumentError, "expected transaction[type] of sale or credit, was: nil")
-    end
-
-    it "raises an exception if not given a type of sale or credit" do
-      expect do
-        Braintree::TransparentRedirect.transaction_data(
-          :redirect_url => "http://example.com",
-          :transaction => {:amount => "100.00", :type => "auth"}
-        )
-      end.to raise_error(ArgumentError, "expected transaction[type] of sale or credit, was: \"auth\"")
-    end
-  end
-
-  describe "self.update_credit_card_data" do
-    it "raises an exception if any keys are invalid" do
-      expect do
-        Braintree::TransparentRedirect.update_credit_card_data(
-          :credit_card => {:number => "ok", :invalid_key => "bad"}
-        )
-      end.to raise_error(ArgumentError, "invalid keys: credit_card[invalid_key]")
-    end
-
-    it "raises an exception if not given a payment_method_token" do
-      expect do
-        Braintree::TransparentRedirect.update_credit_card_data({})
-      end.to raise_error(ArgumentError, "expected params to contain :payment_method_token of payment method to update")
-    end
-  end
-
-  describe "self.update_customer_data" do
-    it "raises an exception if any keys are invalid" do
-      expect do
-        Braintree::TransparentRedirect.update_customer_data(
-          :customer => {:first_name => "ok", :invalid_key => "bad"}
-        )
-      end.to raise_error(ArgumentError, "invalid keys: customer[invalid_key]")
-    end
-
-    it "raises an exception if not given a customer_id" do
-      expect do
-        Braintree::TransparentRedirect.update_customer_data({})
-      end.to raise_error(ArgumentError, "expected params to contain :customer_id of customer to update")
-    end
-  end
-
-  describe "self._data" do
-    it "raises an exception if :redirect_url isn't given" do
-      expect do
-        Braintree::TransparentRedirect.create_customer_data(:redirect_url => nil)
-      end.to raise_error(ArgumentError, "expected params to contain :redirect_url")
-    end
-
-    it "only encodes tr data once" do
-      tr_data = Braintree::TransparentRedirect.create_customer_data(:redirect_url => "example.com")
-
-      tr_data.should include("|")
-      tr_data.should include("&")
-    end
-  end
-
-  def add_hash_to_query_string(query_string_without_hash)
-    hash = Braintree::SignatureService.new(Braintree::Configuration.private_key).hash(query_string_without_hash)
-    query_string_without_hash + "&hash=" + hash
-  end
-end
-