braintree 2.10.0 → 4.26.0

data/spec/integration/braintree/exchange_rate_quote_spec.rb

@@ -0,0 +1,97 @@
+require File.expand_path(File.dirname(__FILE__) + "/../../spec_helper")
+require File.expand_path(File.dirname(__FILE__) + "/client_api/spec_helper")
+
+describe Braintree::ExchangeRateQuoteGateway do
+  let(:gateway) do
+    Braintree::Gateway.new(
+      :environment => :development,
+      :merchant_id => "integration_merchant_id",
+      :public_key => "integration_public_key",
+      :private_key => "integration_private_key",
+    )
+  end
+
+  describe "generate" do
+    def quote_input_request
+      gateway.exchange_rate_quote.generate({quotes: [quote_input]})
+    end
+
+    let(:quote_input) do
+      {
+        :baseCurrency => "EUR",
+        :quoteCurrency => "GBP",
+        :baseAmount => "20.00",
+        :markup => "4.00"
+      }
+    end
+
+    it "generates exchange rate quotes" do
+      result = quote_input_request
+      quotes = result[:quotes]
+
+      expect(quotes[0][:id]).not_to be_nil
+      expect(quotes[0][:baseAmount]).not_to be_nil
+      expect(quotes[0][:quoteAmount]).not_to be_nil
+      expect(quotes[0][:exchangeRate]).not_to be_nil
+      expect(quotes[0][:expiresAt]).not_to be_nil
+      expect(quotes[0][:refreshesAt]).not_to be_nil
+
+      expect(quotes[1][:id]).not_to be_nil
+      expect(quotes[1][:baseAmount]).not_to be_nil
+      expect(quotes[1][:quoteAmount]).not_to be_nil
+      expect(quotes[1][:exchangeRate]).not_to be_nil
+      expect(quotes[1][:expiresAt]).not_to be_nil
+      expect(quotes[1][:refreshesAt]).not_to be_nil
+    end
+
+    context "when base currency input param is not passed" do
+      let(:quote_input) do
+        {
+          :quoteCurrency => "GBP",
+          :baseAmount => "20.00",
+          :markup => "4.00"
+        }
+      end
+      let(:error_message) { "baseCurrency" }
+
+      it "raises an UnexpectedError" do
+        expect do
+          quote_input_request
+        end.to raise_error(Braintree::UnexpectedError, /#{error_message}/)
+      end
+    end
+
+    context "when quote currency input param is not passed" do
+      let(:quote_input) do
+        {
+          :baseCurrency => "GBP",
+          :baseAmount => "20.00",
+          :markup => "4.00"
+        }
+      end
+      let(:error_message) { "quoteCurrency" }
+
+      it "raises an UnexpectedError" do
+        expect do
+          quote_input_request
+        end.to raise_error(Braintree::UnexpectedError, /#{error_message}/)
+      end
+    end
+
+    context "when base and quote currency input params are not passed" do
+      let(:quote_input) do
+        {
+          :baseAmount => "20.00",
+          :markup => "4.00"
+        }
+      end
+      let(:error_message) { "baseCurrency" }
+
+      it "raises an UnexpectedError" do
+        expect do
+          quote_input_request
+        end.to raise_error(Braintree::UnexpectedError, /#{error_message}/)
+      end
+    end
+  end
+end

data/spec/integration/braintree/graphql_client_spec.rb

@@ -0,0 +1,72 @@
+require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
+
+describe Braintree::GraphQLClient do
+  before :each do
+      @config = Braintree::Configuration.instantiate
+  end
+
+  describe "initialize" do
+    it "assigns overriding graphql headers" do
+      expect(@config.graphql_client.instance_variable_get("@graphql_headers")).to be_kind_of(Hash)
+    end
+  end
+
+  describe "query" do
+    it "makes valid GraphQL queries when given a definition" do
+      definition = <<-GRAPHQL
+      query {
+        ping
+      }
+      GRAPHQL
+
+      response = Braintree::GraphQLClient.new(@config).query(definition)
+
+      expect(response[:data]).to eq({:ping=>"pong"})
+    end
+
+    it "makes valid GraphQL requests when given a definitiona and variable" do
+      definition = <<-GRAPHQL
+mutation CreateClientToken($input: CreateClientTokenInput!) {
+  createClientToken(input: $input) {
+    clientToken
+  }
+}
+      GRAPHQL
+
+      variables = {
+        input: {
+          clientToken: {
+            merchantAccountId: "ABC123"
+          }
+        }
+      }
+
+      response = Braintree::GraphQLClient.new(@config).query(definition, variables)
+
+      expect(response[:data][:createClientToken][:clientToken]).to be_a(String)
+    end
+
+    it "returns results parsable into validation errors" do
+      definition = <<-GRAPHQL
+query TransactionLevelFeeReport($date: Date!, $merchantAccountId: ID) {
+  report {
+    transactionLevelFees(date: $date, merchantAccountId: $merchantAccountId) {
+      url
+    }
+  }
+}
+      GRAPHQL
+
+      variables = {
+        date: "2018-01-01",
+        merchantAccountId: "some_merchant"
+      }
+
+      response = Braintree::GraphQLClient.new(@config).query(definition, variables)
+      errors = Braintree::ValidationErrorCollection.new(response)
+
+      expect(errors.size).to eq(1)
+      expect(errors.first.message).to eq("Invalid merchant account id: some_merchant")
+    end
+  end
+end

data/spec/integration/braintree/http_spec.rb

@@ -7,7 +7,8 @@ describe Braintree::Http do
         original_key = Braintree::Configuration.public_key
         Braintree::Configuration.public_key = "invalid_public_key"
         expect do
-          Braintree::Configuration.instantiate.http.get "/customers"
+          config = Braintree::Configuration.instantiate
+          config.http.get("#{config.base_merchant_path}/customers")
         end.to raise_error(Braintree::AuthenticationError)
       ensure
         Braintree::Configuration.public_key = original_key
@@ -16,7 +17,8 @@ describe Braintree::Http do
 
     it "raises an AuthorizationError if authorization fails" do
       expect do
-        Braintree::Configuration.instantiate.http.get "/users"
+        config = Braintree::Configuration.instantiate
+        config.http.get("#{config.base_merchant_path}/home")
       end.to raise_error(Braintree::AuthorizationError)
     end
   end
@@ -32,7 +34,7 @@ describe Braintree::Http do
           Braintree::Configuration.logger.level = Logger::INFO
           Braintree::Customer.all
           utc_or_gmt = Time.now.utc.strftime("%Z")
-          output.string.should include("[Braintree] [10/Oct/2009 13:55:36 #{utc_or_gmt}] POST /customers/advanced_search_ids 200")
+          expect(output.string).to include("[Braintree] [10/Oct/2009 13:55:36 #{utc_or_gmt}] POST /merchants/integration_merchant_id/customers/advanced_search_ids 200")
         end
       ensure
         Braintree::Configuration.logger = old_logger
@@ -52,72 +54,128 @@ describe Braintree::Http do
             :customer_id => customer.id,
             :cardholder_name => "Sam Jones",
             :number => Braintree::Test::CreditCardNumbers::Visa,
-            :expiration_date => "05/2009"
+            :expiration_date => "05/2009",
           )
-          result.success?.should == true
+          expect(result.success?).to eq(true)
           utc_or_gmt = Time.now.utc.strftime("%Z")
-          output.string.should include("[Braintree] [10/Oct/2009 13:55:36 #{utc_or_gmt}] POST /payment_methods")
-          output.string.should include("[Braintree]   <cardholder-name>Sam Jones</cardholder-name>")
-          output.string.should include("[Braintree]   <number>401288******1881</number>")
-          output.string.should include("[Braintree] [10/Oct/2009 13:55:36 #{utc_or_gmt}] 201 Created")
-          output.string.should match(/\[Braintree\]   <token>\w+<\/token>/)
+          expect(output.string).to include("[Braintree] [10/Oct/2009 13:55:36 #{utc_or_gmt}] POST /merchants/integration_merchant_id/payment_methods")
+          expect(output.string).to include("[Braintree]   <cardholder-name>Sam Jones</cardholder-name>")
+          expect(output.string).to include("[Braintree]   <number>401288******1881</number>")
+          expect(output.string).to include("[Braintree] [10/Oct/2009 13:55:36 #{utc_or_gmt}] 201 Created")
+          expect(output.string).to match(/\[Braintree\]   <token>\w+<\/token>/)
         end
       ensure
         Braintree::Configuration.logger = old_logger
       end
     end
 
+    it "posts multipart for file uploads" do
+      config = Braintree::Configuration.instantiate
+      file = File.new("#{File.dirname(__FILE__)}/../../fixtures/files/bt_logo.png", "r")
+      response = config.http.post("#{config.base_merchant_path}/document_uploads", {"document_upload[kind]" => "evidence_document"}, file)
+      expect(response[:document_upload][:content_type]).to eq("image/png")
+      expect(response[:document_upload][:id]).not_to be_nil
+    end
+
     describe "user_agent" do
       after do
         Braintree::Configuration.custom_user_agent = nil
       end
 
       it "sets the User-Agent header using the default user agent" do
-        response = Braintree::Configuration.instantiate.http.get "/test/headers"
-        response[:headers][:HTTP_USER_AGENT].should == "Braintree Ruby Gem #{Braintree::Version::String}"
+        config = Braintree::Configuration.instantiate
+        response = config.http.get("#{config.base_merchant_path}/test/headers")
+        expect(response[:headers][:HTTP_USER_AGENT]).to eq("Braintree Ruby Gem #{Braintree::Version::String}")
       end
 
       it "sets the User-Agent header using a customer user agent" do
         Braintree::Configuration.custom_user_agent = "ActiveMerchant 1.2.3"
-        response = Braintree::Configuration.instantiate.http.get "/test/headers"
-        response[:headers][:HTTP_USER_AGENT].should == "Braintree Ruby Gem #{Braintree::Version::String} (ActiveMerchant 1.2.3)"
+        config = Braintree::Configuration.instantiate
+        response = config.http.get("#{config.base_merchant_path}/test/headers")
+        expect(response[:headers][:HTTP_USER_AGENT]).to eq("Braintree Ruby Gem #{Braintree::Version::String} (ActiveMerchant 1.2.3)")
       end
     end
 
-    describe "ssl verification" do
-      it "rejects when the certificate isn't verified by our certificate authority (self-signed)" do
-        config = Braintree::Configuration.instantiate
-        config.stub(:ssl?).and_return(true)
-        config.stub(:port).and_return(8443)
+    describe "ssl_version" do
+      xit "causes failed requests to sandbox with incompatible SSL version" do
+        begin
+          original_env = Braintree::Configuration.environment
+          Braintree::Configuration.environment = :sandbox
+          Braintree::Configuration.ssl_version = :TLSv1
+          allow(Braintree::Configuration).to receive(:base_merchant_path).and_return("/")
 
-        start_ssl_server do
           expect do
-            config.http._http_do(Net::HTTP::Get, "/login")
-          end.to raise_error(Braintree::SSLCertificateError, /Preverify: false, Error: self signed certificate/)
+            Braintree::Configuration.instantiate.http._http_do(Net::HTTP::Get, "/login")
+          end.to raise_error(Braintree::SSLCertificateError)
+        ensure
+          Braintree::Configuration.environment = original_env
+          Braintree::Configuration.ssl_version = nil
         end
       end
 
-      it "rejets when the certificate is signed by a different (but valid) root CA" do
-        # Random CA root file from a different certificate authority
-        config = Braintree::Configuration.instantiate
-        config.stub(:ca_file).and_return(
-          File.expand_path(File.join(File.dirname(__FILE__), "..", "..", "ssl", "geotrust_global.crt"))
-        )
-        config.stub(:ssl?).and_return(true)
-        config.stub(:port).and_return(8443)
+      it "results in successful requests to sandbox with up-to-date SSL version" do
+        begin
+          original_env = Braintree::Configuration.environment
+          Braintree::Configuration.environment = :sandbox
+          Braintree::Configuration.ssl_version = :TLSv1_2
+          allow(Braintree::Configuration).to receive(:base_merchant_path).and_return("/")
 
-        start_ssl_server do
           expect do
-            config.http._http_do(Net::HTTP::Get, "/login")
-          end.to raise_error(Braintree::SSLCertificateError, /Preverify: false, Error: self signed certificate/)
+            Braintree::Configuration.instantiate.http._http_do(Net::HTTP::Get, "/login")
+          end.to_not raise_error
+        ensure
+          Braintree::Configuration.environment = original_env
+          Braintree::Configuration.ssl_version = nil
+        end
+      end
+    end
+
+    describe "ssl verification" do
+      it "rejects when the certificate isn't verified by our certificate authority (self-signed)" do
+        begin
+          original_env = Braintree::Configuration.environment
+          Braintree::Configuration.environment = :development
+          config = Braintree::Configuration.instantiate
+          allow(config).to receive(:ssl?).and_return(true)
+          allow(config).to receive(:port).and_return(SSL_TEST_PORT)
+
+          start_ssl_server do
+            expect do
+              config.http._http_do(Net::HTTP::Get, "/login")
+            end.to raise_error(Braintree::SSLCertificateError)
+          end
+        ensure
+          Braintree::Configuration.environment = original_env
         end
       end
 
-      it "accepts the certificate on the QA server" do
+      it "rejects when the certificate is signed by a different (but valid) root CA" do
+        begin
+          original_env = Braintree::Configuration.environment
+          Braintree::Configuration.environment = :development
+          # Random CA root file from a different certificate authority
+          config = Braintree::Configuration.instantiate
+          allow(config).to receive(:ca_file).and_return(
+            File.expand_path(File.join(File.dirname(__FILE__), "..", "..", "ssl", "geotrust_global.crt")),
+          )
+          allow(config).to receive(:ssl?).and_return(true)
+          allow(config).to receive(:port).and_return(SSL_TEST_PORT)
+
+          start_ssl_server do
+            expect do
+              config.http._http_do(Net::HTTP::Get, "/login")
+            end.to raise_error(Braintree::SSLCertificateError)
+          end
+        ensure
+          Braintree::Configuration.environment = original_env
+        end
+      end
+
+      it "accepts the certificate on the qa server" do
         begin
           original_env = Braintree::Configuration.environment
           Braintree::Configuration.environment = :qa
-          Braintree::Configuration.stub(:base_merchant_path).and_return("/")
+          allow(Braintree::Configuration).to receive(:base_merchant_path).and_return("/")
 
           expect do
             Braintree::Configuration.instantiate.http._http_do(Net::HTTP::Get, "/login")
@@ -131,7 +189,7 @@ describe Braintree::Http do
         begin
           original_env = Braintree::Configuration.environment
           Braintree::Configuration.environment = :sandbox
-          Braintree::Configuration.stub(:base_merchant_path).and_return("/")
+          allow(Braintree::Configuration).to receive(:base_merchant_path).and_return("/")
 
           expect do
             Braintree::Configuration.instantiate.http._http_do(Net::HTTP::Get, "/login")
@@ -145,7 +203,7 @@ describe Braintree::Http do
         begin
           original_env = Braintree::Configuration.environment
           Braintree::Configuration.environment = :production
-          Braintree::Configuration.stub(:base_merchant_path).and_return("/")
+          allow(Braintree::Configuration).to receive(:base_merchant_path).and_return("/")
 
           expect do
             Braintree::Configuration.instantiate.http._http_do(Net::HTTP::Get, "/login")
@@ -158,10 +216,10 @@ describe Braintree::Http do
       it "raises an appropriate error if certificate fails validation" do
         begin
           original_env = Braintree::Configuration.environment
-          Braintree::Configuration.environment = :qa
+          Braintree::Configuration.environment = :sandbox
           config = Braintree::Configuration.instantiate
-          config.stub(:base_merchant_path).and_return("/")
-          config.stub(:ca_file).and_return("does_not_exist")
+          allow(config).to receive(:base_merchant_path).and_return("/")
+          allow(config).to receive(:ca_file).and_return("does_not_exist")
 
           expect do
             config.http._http_do(Net::HTTP::Get, "/login")
@@ -174,19 +232,15 @@ describe Braintree::Http do
   end
 
   describe "self._verify_ssl_certificate" do
-    it "raises if preverify is false" do
+    it "is false if preverify is false" do
       context = OpenSSL::X509::StoreContext.new(OpenSSL::X509::Store.new)
-      expect do
-        Braintree::Configuration.instantiate.http._verify_ssl_certificate(false, context)
-      end.to raise_error(Braintree::SSLCertificateError)
+      expect(Braintree::Configuration.instantiate.http._verify_ssl_certificate(false, context)).to eq(false)
     end
 
-    it "raise if ssl_context doesn't have an error code of 0" do
+    it "returns false if ssl_context doesn't have an error code of 0" do
       context = OpenSSL::X509::StoreContext.new(OpenSSL::X509::Store.new)
       context.error = 19 # ca_file incorrect, self-signed
-      expect do
-        Braintree::Configuration.instantiate.http._verify_ssl_certificate(true, context)
-      end.to raise_error(Braintree::SSLCertificateError)
+      expect(Braintree::Configuration.instantiate.http._verify_ssl_certificate(true, context)).to eq(false)
     end
 
     it "doesn't raise if there is no error" do
@@ -201,13 +255,10 @@ describe Braintree::Http do
         old_logger = Braintree::Configuration.logger
         output = StringIO.new
         Braintree::Configuration.logger = Logger.new(output)
-        utc_or_gmt = Time.now.utc.strftime("%Z")
         context = OpenSSL::X509::StoreContext.new(OpenSSL::X509::Store.new)
         context.error = 19
-        expect do
-          Braintree::Configuration.instantiate.http._verify_ssl_certificate(false, context)
-        end.to raise_error(Braintree::SSLCertificateError)
-        output.string.should include("SSL Verification failed -- Preverify: false, Error: self signed certificate in certificate chain (19)")
+        expect(Braintree::Configuration.instantiate.http._verify_ssl_certificate(false, context)).to eq(false)
+        expect(output.string).to include("SSL Verification failed -- Preverify: false, Error: self signed certificate in certificate chain (19)")
       ensure
         Braintree::Configuration.logger = old_logger
       end
@@ -218,12 +269,11 @@ describe Braintree::Http do
         old_logger = Braintree::Configuration.logger
         output = StringIO.new
         Braintree::Configuration.logger = Logger.new(output)
-        utc_or_gmt = Time.now.utc.strftime("%Z")
         context = OpenSSL::X509::StoreContext.new(OpenSSL::X509::Store.new)
         expect do
           Braintree::Configuration.instantiate.http._verify_ssl_certificate(true, context)
-        end.to_not raise_error(Braintree::SSLCertificateError)
-        output.string.should == ""
+        end.to_not raise_error
+        expect(output.string).to eq("")
       ensure
         Braintree::Configuration.logger = old_logger
       end